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_types.h"
25 #include "cellular_data_manager_stub.h"
26 #include "data_sim_account_callback.h"
27 #include "system_ability_definition.h"
28 #include <fuzzer/FuzzedDataProvider.h>
29 #include "icellular_data_manager.h"
30
31 using namespace OHOS::Telephony;
32 namespace OHOS {
33 static bool g_isInited = false;
34 constexpr int32_t SLOT_NUM_MAX = 3;
35 constexpr int32_t APN_ID_MAX = 5;
36 constexpr int32_t APN_STRING_LENGTH = 10;
37 constexpr int32_t NET_CAPABILITY_MAX = 32;
38 static constexpr const char16_t *DESCRIPTOR = u"OHOS.Telephony.ICellularDataManager";
GetDescriptor()39 static inline const std::u16string GetDescriptor()
40 {
41 return DESCRIPTOR;
42 }
IsServiceInited()43 bool IsServiceInited()
44 {
45 if (!g_isInited) {
46 DelayedSingleton<CellularDataService>::GetInstance()->OnStart();
47 if (DelayedSingleton<CellularDataService>::GetInstance()->GetServiceRunningState() ==
48 static_cast<int32_t>(ServiceRunningState::STATE_RUNNING)) {
49 g_isInited = true;
50 }
51 }
52 return g_isInited;
53 }
54
EnableCellularData(const uint8_t * data,size_t size)55 void EnableCellularData(const uint8_t *data, size_t size)
56 {
57 if (!IsServiceInited()) {
58 return;
59 }
60
61 MessageParcel dataMessageParcel;
62 if (!dataMessageParcel.WriteInterfaceToken(GetDescriptor())) {
63 return;
64 }
65 dataMessageParcel.WriteBuffer(data, size);
66 dataMessageParcel.RewindRead(0);
67 uint32_t code = static_cast<uint32_t>(ICellularDataManagerIpcCode::COMMAND_ENABLE_CELLULAR_DATA);
68 MessageParcel reply;
69 MessageOption option(MessageOption::TF_SYNC);
70 DelayedSingleton<CellularDataService>::GetInstance()->OnRemoteRequest(code, dataMessageParcel, reply, option);
71 }
72
EnableIntelligenceSwitch(const uint8_t * data,size_t size)73 void EnableIntelligenceSwitch(const uint8_t *data, size_t size)
74 {
75 if (!IsServiceInited()) {
76 return;
77 }
78
79 MessageParcel dataMessageParcel;
80 if (!dataMessageParcel.WriteInterfaceToken(GetDescriptor())) {
81 return;
82 }
83 dataMessageParcel.WriteBuffer(data, size);
84 dataMessageParcel.RewindRead(0);
85 uint32_t code = static_cast<uint32_t>(ICellularDataManagerIpcCode::COMMAND_ENABLE_INTELLIGENCE_SWITCH);
86 MessageParcel reply;
87 MessageOption option(MessageOption::TF_SYNC);
88 DelayedSingleton<CellularDataService>::GetInstance()->OnRemoteRequest(code, dataMessageParcel, reply, option);
89 }
90
GetCellularDataState(const uint8_t * data,size_t size)91 void GetCellularDataState(const uint8_t *data, size_t size)
92 {
93 if (!IsServiceInited()) {
94 return;
95 }
96
97 MessageParcel dataMessageParcel;
98 if (!dataMessageParcel.WriteInterfaceToken(GetDescriptor())) {
99 return;
100 }
101 dataMessageParcel.WriteBuffer(data, size);
102 dataMessageParcel.RewindRead(0);
103 uint32_t code = static_cast<uint32_t>(ICellularDataManagerIpcCode::COMMAND_GET_CELLULAR_DATA_STATE);
104 MessageParcel reply;
105 MessageOption option(MessageOption::TF_SYNC);
106 DelayedSingleton<CellularDataService>::GetInstance()->OnRemoteRequest(code, dataMessageParcel, reply, option);
107 }
108
IsCellularDataEnabled(const uint8_t * data,size_t size)109 void IsCellularDataEnabled(const uint8_t *data, size_t size)
110 {
111 if (!IsServiceInited()) {
112 return;
113 }
114
115 MessageParcel dataMessageParcel;
116 if (!dataMessageParcel.WriteInterfaceToken(GetDescriptor())) {
117 return;
118 }
119 dataMessageParcel.WriteBuffer(data, size);
120 dataMessageParcel.RewindRead(0);
121 uint32_t code = static_cast<uint32_t>(ICellularDataManagerIpcCode::COMMAND_IS_CELLULAR_DATA_ENABLED);
122 MessageParcel reply;
123 MessageOption option(MessageOption::TF_SYNC);
124 DelayedSingleton<CellularDataService>::GetInstance()->OnRemoteRequest(code, dataMessageParcel, reply, option);
125 }
126
IsCellularDataRoamingEnabled(const uint8_t * data,size_t size)127 void IsCellularDataRoamingEnabled(const uint8_t *data, size_t size)
128 {
129 if (!IsServiceInited()) {
130 return;
131 }
132 FuzzedDataProvider fdp(data, size);
133 int32_t slotId = fdp.ConsumeIntegralInRange<uint32_t>(0, SLOT_NUM_MAX);
134 MessageParcel dataMessageParcel;
135 if (!dataMessageParcel.WriteInterfaceToken(GetDescriptor())) {
136 return;
137 }
138 dataMessageParcel.WriteInt32(slotId);
139 dataMessageParcel.WriteBuffer(data, size);
140 dataMessageParcel.RewindRead(0);
141 uint32_t code = static_cast<uint32_t>(ICellularDataManagerIpcCode::COMMAND_IS_CELLULAR_DATA_ROAMING_ENABLED);
142 MessageParcel reply;
143 MessageOption option(MessageOption::TF_SYNC);
144 DelayedSingleton<CellularDataService>::GetInstance()->OnRemoteRequest(code, dataMessageParcel, reply, option);
145 }
146
GetDefaultCellularDataSlotId(const uint8_t * data,size_t size)147 void GetDefaultCellularDataSlotId(const uint8_t *data, size_t size)
148 {
149 if (!IsServiceInited()) {
150 return;
151 }
152
153 MessageParcel dataMessageParcel;
154 if (!dataMessageParcel.WriteInterfaceToken(GetDescriptor())) {
155 return;
156 }
157 dataMessageParcel.WriteBuffer(data, size);
158 dataMessageParcel.RewindRead(0);
159 uint32_t code = static_cast<uint32_t>(ICellularDataManagerIpcCode::COMMAND_GET_DEFAULT_CELLULAR_DATA_SLOT_ID);
160 MessageParcel reply;
161 MessageOption option(MessageOption::TF_SYNC);
162 DelayedSingleton<CellularDataService>::GetInstance()->OnRemoteRequest(code, dataMessageParcel, reply, option);
163 }
164
EnableCellularDataRoaming(const uint8_t * data,size_t size)165 void EnableCellularDataRoaming(const uint8_t *data, size_t size)
166 {
167 if (!IsServiceInited()) {
168 return;
169 }
170
171 FuzzedDataProvider fdp(data, size);
172 int32_t slotId = fdp.ConsumeIntegralInRange<uint32_t>(0, SLOT_NUM_MAX);
173 MessageParcel dataMessageParcel;
174 if (!dataMessageParcel.WriteInterfaceToken(GetDescriptor())) {
175 return;
176 }
177 dataMessageParcel.WriteInt32(slotId);
178 dataMessageParcel.WriteBuffer(data, size);
179 dataMessageParcel.RewindRead(0);
180 uint32_t code = static_cast<uint32_t>(ICellularDataManagerIpcCode::COMMAND_ENABLE_CELLULAR_DATA_ROAMING);
181 MessageParcel reply;
182 MessageOption option(MessageOption::TF_SYNC);
183 DelayedSingleton<CellularDataService>::GetInstance()->OnRemoteRequest(code, dataMessageParcel, reply, option);
184 }
185
SetDefaultCellularDataSlotId(const uint8_t * data,size_t size)186 void SetDefaultCellularDataSlotId(const uint8_t *data, size_t size)
187 {
188 if (!IsServiceInited()) {
189 return;
190 }
191
192 FuzzedDataProvider fdp(data, size);
193 int32_t slotId = fdp.ConsumeIntegralInRange<uint32_t>(0, SLOT_NUM_MAX);
194 MessageParcel dataMessageParcel;
195 if (!dataMessageParcel.WriteInterfaceToken(GetDescriptor())) {
196 return;
197 }
198 dataMessageParcel.WriteInt32(slotId);
199 dataMessageParcel.WriteBuffer(data, size);
200 dataMessageParcel.RewindRead(0);
201 uint32_t code = static_cast<uint32_t>(ICellularDataManagerIpcCode::COMMAND_SET_DEFAULT_CELLULAR_DATA_SLOT_ID);
202 MessageParcel reply;
203 MessageOption option(MessageOption::TF_SYNC);
204 DelayedSingleton<CellularDataService>::GetInstance()->OnRemoteRequest(code, dataMessageParcel, reply, option);
205 }
206
HasInternetCapability(const uint8_t * data,size_t size)207 void HasInternetCapability(const uint8_t *data, size_t size)
208 {
209 if (!IsServiceInited()) {
210 return;
211 }
212
213 FuzzedDataProvider fdp(data, size);
214 int32_t slotId = fdp.ConsumeIntegralInRange<uint32_t>(0, SLOT_NUM_MAX);
215 MessageParcel dataMessageParcel;
216 if (!dataMessageParcel.WriteInterfaceToken(GetDescriptor())) {
217 return;
218 }
219 dataMessageParcel.WriteInt32(slotId);
220 dataMessageParcel.WriteBuffer(data, size);
221 dataMessageParcel.RewindRead(0);
222 uint32_t code = static_cast<uint32_t>(ICellularDataManagerIpcCode::COMMAND_HAS_INTERNET_CAPABILITY);
223 MessageParcel reply;
224 MessageOption option(MessageOption::TF_SYNC);
225 DelayedSingleton<CellularDataService>::GetInstance()->OnRemoteRequest(code, dataMessageParcel, reply, option);
226 }
227
ClearCellularDataConnections(const uint8_t * data,size_t size)228 void ClearCellularDataConnections(const uint8_t *data, size_t size)
229 {
230 if (!IsServiceInited()) {
231 return;
232 }
233
234 FuzzedDataProvider fdp(data, size);
235 int32_t slotId = fdp.ConsumeIntegralInRange<uint32_t>(0, SLOT_NUM_MAX);
236 MessageParcel dataMessageParcel;
237 if (!dataMessageParcel.WriteInterfaceToken(GetDescriptor())) {
238 return;
239 }
240 dataMessageParcel.WriteInt32(slotId);
241 dataMessageParcel.WriteBuffer(data, size);
242 dataMessageParcel.RewindRead(0);
243 uint32_t code = static_cast<uint32_t>(ICellularDataManagerIpcCode::COMMAND_CLEAR_CELLULAR_DATA_CONNECTIONS);
244 MessageParcel reply;
245 MessageOption option(MessageOption::TF_SYNC);
246 DelayedSingleton<CellularDataService>::GetInstance()->OnRemoteRequest(code, dataMessageParcel, reply, option);
247 }
248
GetCellularDataFlowType(const uint8_t * data,size_t size)249 void GetCellularDataFlowType(const uint8_t *data, size_t size)
250 {
251 if (!IsServiceInited()) {
252 return;
253 }
254
255 MessageParcel dataMessageParcel;
256 if (!dataMessageParcel.WriteInterfaceToken(GetDescriptor())) {
257 return;
258 }
259 dataMessageParcel.WriteBuffer(data, size);
260 dataMessageParcel.RewindRead(0);
261 uint32_t code = static_cast<uint32_t>(ICellularDataManagerIpcCode::COMMAND_GET_CELLULAR_DATA_FLOW_TYPE);
262 MessageParcel reply;
263 MessageOption option(MessageOption::TF_SYNC);
264 DelayedSingleton<CellularDataService>::GetInstance()->OnRemoteRequest(code, dataMessageParcel, reply, option);
265 }
266
RegisterSimAccountCallback(const uint8_t * data,size_t size)267 void RegisterSimAccountCallback(const uint8_t *data, size_t size)
268 {
269 if (!IsServiceInited()) {
270 return;
271 }
272 MessageParcel dataMessageParcel;
273 if (!dataMessageParcel.WriteInterfaceToken(GetDescriptor())) {
274 return;
275 }
276 sptr<SimAccountCallback> callback = new (std::nothrow) DataSimAccountCallback();
277 if (callback == nullptr) {
278 return;
279 }
280 dataMessageParcel.WriteRemoteObject(callback->AsObject());
281 uint32_t code = static_cast<uint32_t>(ICellularDataManagerIpcCode::COMMAND_REGISTER_SIM_ACCOUNT_CALLBACK);
282 MessageParcel reply;
283 MessageOption option(MessageOption::TF_SYNC);
284 DelayedSingleton<CellularDataService>::GetInstance()->OnRemoteRequest(code, dataMessageParcel, reply, option);
285 }
286
UnregisterSimAccountCallback(const uint8_t * data,size_t size)287 void UnregisterSimAccountCallback(const uint8_t *data, size_t size)
288 {
289 if (!IsServiceInited()) {
290 return;
291 }
292 MessageParcel dataMessageParcel;
293 if (!dataMessageParcel.WriteInterfaceToken(GetDescriptor())) {
294 return;
295 }
296 sptr<SimAccountCallback> callback = new (std::nothrow) DataSimAccountCallback();
297 if (callback == nullptr) {
298 return;
299 }
300 dataMessageParcel.WriteRemoteObject(callback->AsObject());
301 uint32_t code = static_cast<uint32_t>(ICellularDataManagerIpcCode::COMMAND_UNREGISTER_SIM_ACCOUNT_CALLBACK);
302 MessageParcel reply;
303 MessageOption option(MessageOption::TF_SYNC);
304 DelayedSingleton<CellularDataService>::GetInstance()->OnRemoteRequest(code, dataMessageParcel, reply, option);
305 }
306
GetDefaultActReportInfo(const uint8_t * data,size_t size)307 void GetDefaultActReportInfo(const uint8_t *data, size_t size)
308 {
309 if (!IsServiceInited()) {
310 return;
311 }
312 MessageParcel dataMessageParcel;
313 if (!dataMessageParcel.WriteInterfaceToken(GetDescriptor())) {
314 return;
315 }
316 dataMessageParcel.WriteBuffer(data, size);
317 dataMessageParcel.RewindRead(0);
318 uint32_t code = static_cast<uint32_t>(ICellularDataManagerIpcCode::COMMAND_GET_DEFAULT_ACT_REPORT_INFO);
319 MessageParcel reply;
320 MessageOption option(MessageOption::TF_SYNC);
321 DelayedSingleton<CellularDataService>::GetInstance()->OnRemoteRequest(code, dataMessageParcel, reply, option);
322 }
323
GetInternalActReportInfo(const uint8_t * data,size_t size)324 void GetInternalActReportInfo(const uint8_t *data, size_t size)
325 {
326 if (!IsServiceInited()) {
327 return;
328 }
329 MessageParcel dataMessageParcel;
330 if (!dataMessageParcel.WriteInterfaceToken(GetDescriptor())) {
331 return;
332 }
333 dataMessageParcel.WriteBuffer(data, size);
334 dataMessageParcel.RewindRead(0);
335 uint32_t code = static_cast<uint32_t>(ICellularDataManagerIpcCode::COMMAND_GET_INTERNAL_ACT_REPORT_INFO);
336 MessageParcel reply;
337 MessageOption option(MessageOption::TF_SYNC);
338 DelayedSingleton<CellularDataService>::GetInstance()->OnRemoteRequest(code, dataMessageParcel, reply, option);
339 }
340
HandleApnChanged(const uint8_t * data,size_t size)341 void HandleApnChanged(const uint8_t *data, size_t size)
342 {
343 if (!IsServiceInited()) {
344 return;
345 }
346
347 FuzzedDataProvider fdp(data, size);
348 int32_t slotId = fdp.ConsumeIntegralInRange<uint32_t>(0, SLOT_NUM_MAX);
349 MessageParcel dataMessageParcel;
350 if (!dataMessageParcel.WriteInterfaceToken(GetDescriptor())) {
351 return;
352 }
353 dataMessageParcel.WriteInt32(slotId);
354 dataMessageParcel.WriteBuffer(data, size);
355 dataMessageParcel.RewindRead(0);
356 uint32_t code = static_cast<uint32_t>(ICellularDataManagerIpcCode::COMMAND_HANDLE_APN_CHANGED);
357 MessageParcel reply;
358 MessageOption option(MessageOption::TF_SYNC);
359 DelayedSingleton<CellularDataService>::GetInstance()->OnRemoteRequest(code, dataMessageParcel, reply, option);
360 }
361
GetDefaultCellularDataSimId(const uint8_t * data,size_t size)362 void GetDefaultCellularDataSimId(const uint8_t *data, size_t size)
363 {
364 if (!IsServiceInited()) {
365 return;
366 }
367
368 MessageParcel dataMessageParcel;
369 if (!dataMessageParcel.WriteInterfaceToken(GetDescriptor())) {
370 return;
371 }
372 dataMessageParcel.WriteBuffer(data, size);
373 dataMessageParcel.RewindRead(0);
374 uint32_t code = static_cast<uint32_t>(ICellularDataManagerIpcCode::COMMAND_GET_DEFAULT_CELLULAR_DATA_SIM_ID);
375 MessageParcel reply;
376 MessageOption option(MessageOption::TF_SYNC);
377 DelayedSingleton<CellularDataService>::GetInstance()->OnRemoteRequest(code, dataMessageParcel, reply, option);
378 }
379
ClearAllConnections(const uint8_t * data,size_t size)380 void ClearAllConnections(const uint8_t *data, size_t size)
381 {
382 if (!IsServiceInited()) {
383 return;
384 }
385
386 FuzzedDataProvider fdp(data, size);
387 int32_t slotId = fdp.ConsumeIntegralInRange<uint32_t>(0, SLOT_NUM_MAX);
388 int32_t reason = fdp.ConsumeIntegralInRange<int32_t>(
389 0, static_cast<int32_t>(DisConnectionReason::REASON_PERMANENT_REJECT));
390 MessageParcel dataMessageParcel;
391 if (!dataMessageParcel.WriteInterfaceToken(GetDescriptor())) {
392 return;
393 }
394 dataMessageParcel.WriteInt32(slotId);
395 dataMessageParcel.WriteInt32(reason);
396 dataMessageParcel.WriteBuffer(data, size);
397 dataMessageParcel.RewindRead(0);
398 uint32_t code = static_cast<uint32_t>(ICellularDataManagerIpcCode::COMMAND_CLEAR_ALL_CONNECTIONS);
399 MessageParcel reply;
400 MessageOption option(MessageOption::TF_SYNC);
401 DelayedSingleton<CellularDataService>::GetInstance()->OnRemoteRequest(code, dataMessageParcel, reply, option);
402 }
403
GetDataConnApnAttr(const uint8_t * data,size_t size)404 void GetDataConnApnAttr(const uint8_t *data, size_t size)
405 {
406 if (!IsServiceInited()) {
407 return;
408 }
409
410 FuzzedDataProvider fdp(data, size);
411 int32_t slotId = fdp.ConsumeIntegralInRange<uint32_t>(0, SLOT_NUM_MAX);
412 MessageParcel dataMessageParcel;
413 if (!dataMessageParcel.WriteInterfaceToken(GetDescriptor())) {
414 return;
415 }
416 dataMessageParcel.WriteInt32(slotId);
417 dataMessageParcel.WriteBuffer(data, size);
418 dataMessageParcel.RewindRead(0);
419 uint32_t code = static_cast<uint32_t>(ICellularDataManagerIpcCode::COMMAND_GET_DATA_CONN_APN_ATTR);
420 MessageParcel reply;
421 MessageOption option(MessageOption::TF_SYNC);
422 DelayedSingleton<CellularDataService>::GetInstance()->OnRemoteRequest(code, dataMessageParcel, reply, option);
423 }
424
GetDataConnIpType(const uint8_t * data,size_t size)425 void GetDataConnIpType(const uint8_t *data, size_t size)
426 {
427 if (!IsServiceInited()) {
428 return;
429 }
430
431 FuzzedDataProvider fdp(data, size);
432 int32_t slotId = fdp.ConsumeIntegralInRange<uint32_t>(0, SLOT_NUM_MAX);
433 MessageParcel dataMessageParcel;
434 if (!dataMessageParcel.WriteInterfaceToken(GetDescriptor())) {
435 return;
436 }
437 dataMessageParcel.WriteInt32(slotId);
438 dataMessageParcel.WriteBuffer(data, size);
439 dataMessageParcel.RewindRead(0);
440 uint32_t code = static_cast<uint32_t>(ICellularDataManagerIpcCode::COMMAND_GET_DATA_CONN_IP_TYPE);
441 MessageParcel reply;
442 MessageOption option(MessageOption::TF_SYNC);
443 DelayedSingleton<CellularDataService>::GetInstance()->OnRemoteRequest(code, dataMessageParcel, reply, option);
444 }
445
GetApnState(const uint8_t * data,size_t size)446 void GetApnState(const uint8_t *data, size_t size)
447 {
448 if (!IsServiceInited()) {
449 return;
450 }
451
452 FuzzedDataProvider fdp(data, size);
453 int32_t slotId = fdp.ConsumeIntegralInRange<uint32_t>(0, SLOT_NUM_MAX);
454 MessageParcel dataMessageParcel;
455 if (!dataMessageParcel.WriteInterfaceToken(GetDescriptor())) {
456 return;
457 }
458 dataMessageParcel.WriteInt32(slotId);
459 std::string apnType = fdp.ConsumeRandomLengthString(APN_STRING_LENGTH);
460 if (!dataMessageParcel.WriteString16(Str8ToStr16(apnType))) {
461 return;
462 }
463 dataMessageParcel.RewindRead(0);
464 uint32_t code = static_cast<uint32_t>(ICellularDataManagerIpcCode::COMMAND_GET_APN_STATE);
465 MessageParcel reply;
466 MessageOption option(MessageOption::TF_SYNC);
467 DelayedSingleton<CellularDataService>::GetInstance()->OnRemoteRequest(code, dataMessageParcel, reply, option);
468 }
469
GetDataRecoveryState(const uint8_t * data,size_t size)470 void GetDataRecoveryState(const uint8_t *data, size_t size)
471 {
472 if (!IsServiceInited()) {
473 return;
474 }
475
476 MessageParcel dataMessageParcel;
477 if (!dataMessageParcel.WriteInterfaceToken(GetDescriptor())) {
478 return;
479 }
480 dataMessageParcel.WriteBuffer(data, size);
481 dataMessageParcel.RewindRead(0);
482 uint32_t code = static_cast<uint32_t>(ICellularDataManagerIpcCode::COMMAND_GET_DATA_RECOVERY_STATE);
483 MessageParcel reply;
484 MessageOption option(MessageOption::TF_SYNC);
485 DelayedSingleton<CellularDataService>::GetInstance()->OnRemoteRequest(code, dataMessageParcel, reply, option);
486 }
487
GetCellularDataSupplierId(const uint8_t * data,size_t size)488 void GetCellularDataSupplierId(const uint8_t *data, size_t size)
489 {
490 if (!IsServiceInited()) {
491 return;
492 }
493
494 MessageParcel dataMessageParcel;
495 if (!dataMessageParcel.WriteInterfaceToken(GetDescriptor())) {
496 return;
497 }
498 FuzzedDataProvider fdp(data, size);
499 int32_t slotId = fdp.ConsumeIntegralInRange<uint32_t>(0, SLOT_NUM_MAX);
500 dataMessageParcel.WriteInt32(slotId);
501 uint64_t capability = fdp.ConsumeIntegralInRange<uint64_t>(0, NET_CAPABILITY_MAX);
502 dataMessageParcel.WriteUint64(capability);
503 dataMessageParcel.RewindRead(0);
504 uint32_t code = static_cast<uint32_t>(ICellularDataManagerIpcCode::COMMAND_GET_CELLULAR_DATA_SUPPLIER_ID);
505 MessageParcel reply;
506 MessageOption option(MessageOption::TF_SYNC);
507 DelayedSingleton<CellularDataService>::GetInstance()->OnRemoteRequest(code, dataMessageParcel, reply, option);
508 }
509
IsNeedDoRecovery(const uint8_t * data,size_t size)510 void IsNeedDoRecovery(const uint8_t *data, size_t size)
511 {
512 if (!IsServiceInited()) {
513 return;
514 }
515
516 FuzzedDataProvider fdp(data, size);
517 int32_t slotId = fdp.ConsumeIntegralInRange<uint32_t>(0, SLOT_NUM_MAX);
518 MessageParcel dataMessageParcel;
519 if (!dataMessageParcel.WriteInterfaceToken(GetDescriptor())) {
520 return;
521 }
522 dataMessageParcel.WriteInt32(slotId);
523 dataMessageParcel.WriteBuffer(data, size);
524 dataMessageParcel.RewindRead(0);
525 uint32_t code = static_cast<uint32_t>(ICellularDataManagerIpcCode::COMMAND_IS_NEED_DO_RECOVERY);
526 MessageParcel reply;
527 MessageOption option(MessageOption::TF_SYNC);
528 DelayedSingleton<CellularDataService>::GetInstance()->OnRemoteRequest(code, dataMessageParcel, reply, option);
529 }
530
CorrectNetSupplierNoAvailable(const uint8_t * data,size_t size)531 void CorrectNetSupplierNoAvailable(const uint8_t *data, size_t size)
532 {
533 if (!IsServiceInited()) {
534 return;
535 }
536
537 FuzzedDataProvider fdp(data, size);
538 int32_t slotId = fdp.ConsumeIntegralInRange<uint32_t>(0, SLOT_NUM_MAX);
539 MessageParcel dataMessageParcel;
540 if (!dataMessageParcel.WriteInterfaceToken(GetDescriptor())) {
541 return;
542 }
543 dataMessageParcel.WriteInt32(slotId);
544 dataMessageParcel.WriteBuffer(data, size);
545 dataMessageParcel.RewindRead(0);
546 uint32_t code = static_cast<uint32_t>(ICellularDataManagerIpcCode::COMMAND_CORRECT_NET_SUPPLIER_NO_AVAILABLE);
547 MessageParcel reply;
548 MessageOption option(MessageOption::TF_SYNC);
549 DelayedSingleton<CellularDataService>::GetInstance()->OnRemoteRequest(code, dataMessageParcel, reply, option);
550 }
551
GetIfSupportDunApn(const uint8_t * data,size_t size)552 void GetIfSupportDunApn(const uint8_t *data, size_t size)
553 {
554 if (!IsServiceInited()) {
555 return;
556 }
557
558 MessageParcel dataMessageParcel;
559 if (!dataMessageParcel.WriteInterfaceToken(GetDescriptor())) {
560 return;
561 }
562 dataMessageParcel.WriteBuffer(data, size);
563 dataMessageParcel.RewindRead(0);
564 uint32_t code = static_cast<uint32_t>(ICellularDataManagerIpcCode::COMMAND_GET_IF_SUPPORT_DUN_APN);
565 MessageParcel reply;
566 MessageOption option(MessageOption::TF_SYNC);
567 DelayedSingleton<CellularDataService>::GetInstance()->OnRemoteRequest(code, dataMessageParcel, reply, option);
568 }
569
QueryApnIds(const uint8_t * data,size_t size)570 void QueryApnIds(const uint8_t *data, size_t size)
571 {
572 if (!IsServiceInited()) {
573 return;
574 }
575
576 MessageParcel dataMessageParcel;
577 if (!dataMessageParcel.WriteInterfaceToken(GetDescriptor())) {
578 return;
579 }
580 ApnInfo apnInfo;
581 dataMessageParcel.WriteParcelable(&apnInfo);
582 dataMessageParcel.WriteBuffer(data, size);
583 dataMessageParcel.RewindRead(0);
584 uint32_t code = static_cast<uint32_t>(ICellularDataManagerIpcCode::COMMAND_QUERY_APN_IDS);
585 MessageParcel reply;
586 MessageOption option(MessageOption::TF_SYNC);
587 DelayedSingleton<CellularDataService>::GetInstance()->OnRemoteRequest(code, dataMessageParcel, reply, option);
588 }
589
SetPreferApn(const uint8_t * data,size_t size)590 void SetPreferApn(const uint8_t *data, size_t size)
591 {
592 if (!IsServiceInited()) {
593 return;
594 }
595
596 MessageParcel dataMessageParcel;
597 if (!dataMessageParcel.WriteInterfaceToken(GetDescriptor())) {
598 return;
599 }
600 FuzzedDataProvider fdp(data, size);
601 int32_t apnId = fdp.ConsumeIntegralInRange<uint32_t>(0, APN_ID_MAX);
602 dataMessageParcel.WriteInt32(apnId);
603 dataMessageParcel.RewindRead(0);
604 uint32_t code = static_cast<uint32_t>(ICellularDataManagerIpcCode::COMMAND_SET_PREFER_APN);
605 MessageParcel reply;
606 MessageOption option(MessageOption::TF_SYNC);
607 DelayedSingleton<CellularDataService>::GetInstance()->OnRemoteRequest(code, dataMessageParcel, reply, option);
608 }
609
InitCellularDataController(const uint8_t * data,size_t size)610 void InitCellularDataController(const uint8_t *data, size_t size)
611 {
612 if (!IsServiceInited()) {
613 return;
614 }
615
616 FuzzedDataProvider fdp(data, size);
617 int32_t slotId = fdp.ConsumeIntegralInRange<uint32_t>(0, SLOT_NUM_MAX);
618 MessageParcel dataMessageParcel;
619 if (!dataMessageParcel.WriteInterfaceToken(GetDescriptor())) {
620 return;
621 }
622 dataMessageParcel.WriteInt32(slotId);
623 dataMessageParcel.WriteBuffer(data, size);
624 dataMessageParcel.RewindRead(0);
625 uint32_t code = static_cast<uint32_t>(ICellularDataManagerIpcCode::COMMAND_INIT_CELLULAR_DATA_CONTROLLER);
626 MessageParcel reply;
627 MessageOption option(MessageOption::TF_SYNC);
628 DelayedSingleton<CellularDataService>::GetInstance()->OnRemoteRequest(code, dataMessageParcel, reply, option);
629 }
630
EstablishAllApnsIfConnectable(const uint8_t * data,size_t size)631 void EstablishAllApnsIfConnectable(const uint8_t *data, size_t size)
632 {
633 if (!IsServiceInited()) {
634 return;
635 }
636
637 FuzzedDataProvider fdp(data, size);
638 int32_t slotId = fdp.ConsumeIntegralInRange<uint32_t>(0, SLOT_NUM_MAX);
639 MessageParcel dataMessageParcel;
640 if (!dataMessageParcel.WriteInterfaceToken(GetDescriptor())) {
641 return;
642 }
643 dataMessageParcel.WriteInt32(slotId);
644 dataMessageParcel.WriteBuffer(data, size);
645 dataMessageParcel.RewindRead(0);
646 uint32_t code = static_cast<uint32_t>(ICellularDataManagerIpcCode::COMMAND_ESTABLISH_ALL_APNS_IF_CONNECTABLE);
647 MessageParcel reply;
648 MessageOption option(MessageOption::TF_SYNC);
649 DelayedSingleton<CellularDataService>::GetInstance()->OnRemoteRequest(code, dataMessageParcel, reply, option);
650 }
651
ReleaseCellularDataConnection(const uint8_t * data,size_t size)652 void ReleaseCellularDataConnection(const uint8_t *data, size_t size)
653 {
654 if (!IsServiceInited()) {
655 return;
656 }
657
658 FuzzedDataProvider fdp(data, size);
659 int32_t slotId = fdp.ConsumeIntegralInRange<uint32_t>(0, SLOT_NUM_MAX);
660 MessageParcel dataMessageParcel;
661 if (!dataMessageParcel.WriteInterfaceToken(GetDescriptor())) {
662 return;
663 }
664 dataMessageParcel.WriteInt32(slotId);
665 dataMessageParcel.WriteBuffer(data, size);
666 dataMessageParcel.RewindRead(0);
667 uint32_t code = static_cast<uint32_t>(ICellularDataManagerIpcCode::COMMAND_RELEASE_CELLULAR_DATA_CONNECTION);
668 MessageParcel reply;
669 MessageOption option(MessageOption::TF_SYNC);
670 DelayedSingleton<CellularDataService>::GetInstance()->OnRemoteRequest(code, dataMessageParcel, reply, option);
671 }
672
GetSupplierRegisterState(const uint8_t * data,size_t size)673 void GetSupplierRegisterState(const uint8_t *data, size_t size)
674 {
675 if (!IsServiceInited()) {
676 return;
677 }
678
679 FuzzedDataProvider fdp(data, size);
680 int32_t slotId = fdp.ConsumeIntegralInRange<uint32_t>(0, SLOT_NUM_MAX);
681 MessageParcel dataMessageParcel;
682 if (!dataMessageParcel.WriteInterfaceToken(GetDescriptor())) {
683 return;
684 }
685 dataMessageParcel.WriteInt32(slotId);
686 dataMessageParcel.WriteBuffer(data, size);
687 dataMessageParcel.RewindRead(0);
688 uint32_t code = static_cast<uint32_t>(ICellularDataManagerIpcCode::COMMAND_GET_SUPPLIER_REGISTER_STATE);
689 MessageParcel reply;
690 MessageOption option(MessageOption::TF_SYNC);
691 DelayedSingleton<CellularDataService>::GetInstance()->OnRemoteRequest(code, dataMessageParcel, reply, option);
692 }
693
ReleaseNetFuzzTest(const uint8_t * data,size_t size)694 void ReleaseNetFuzzTest(const uint8_t *data, size_t size)
695 {
696 if (!IsServiceInited()) {
697 return;
698 }
699
700 FuzzedDataProvider fdp(data, size);
701 OHOS::Telephony::NetRequest request;
702 request.ident = fdp.ConsumeRandomLengthString(APN_ID_MAX + 1);
703 DelayedSingleton<CellularDataService>::GetInstance()->ReleaseNet(request);
704 DelayedSingleton<CellularDataService>::GetInstance()->RemoveUid(request);
705 DelayedSingleton<CellularDataService>::GetInstance()->AddUid(request);
706 DelayedSingleton<CellularDataService>::GetInstance()->RequestNet(request);
707 }
708
DumpFuzzTest(const uint8_t * data,size_t size)709 void DumpFuzzTest(const uint8_t *data, size_t size)
710 {
711 if (!IsServiceInited()) {
712 return;
713 }
714
715 FuzzedDataProvider fdp(data, size);
716 std::int32_t fd = fdp.ConsumeIntegralInRange<int32_t>(-1, NET_CAPABILITY_MAX);
717 std::vector<std::u16string> args;
718 DelayedSingleton<CellularDataService>::GetInstance()->Dump(fd, args);
719 DelayedSingleton<CellularDataService>::GetInstance()->OnStop();
720 g_isInited = false;
721 }
722
DispatchEventFuzzTest(const uint8_t * data,size_t size)723 void DispatchEventFuzzTest(const uint8_t *data, size_t size)
724 {
725 if (!IsServiceInited()) {
726 return;
727 }
728
729 FuzzedDataProvider fdp(data, size);
730 int32_t slotId = fdp.ConsumeIntegralInRange<uint32_t>(0, SLOT_NUM_MAX);
731 AppExecFwk::InnerEvent::Pointer event(nullptr, nullptr);
732 DelayedSingleton<CellularDataService>::GetInstance()->DispatchEvent(slotId, event);
733 DelayedSingleton<CellularDataService>::GetInstance()->UnRegisterAllNetSpecifier();
734 }
735
StrategySwitchFuzzTest(const uint8_t * data,size_t size)736 void StrategySwitchFuzzTest(const uint8_t *data, size_t size)
737 {
738 if (!IsServiceInited()) {
739 return;
740 }
741
742 FuzzedDataProvider fdp(data, size);
743 int32_t slotId = fdp.ConsumeIntegralInRange<uint32_t>(0, SLOT_NUM_MAX);
744 bool enable = fdp.ConsumeBool();
745 DelayedSingleton<CellularDataService>::GetInstance()->GetBeginTime();
746 DelayedSingleton<CellularDataService>::GetInstance()->GetEndTime();
747 DelayedSingleton<CellularDataService>::GetInstance()->GetCellularDataSlotIdDump();
748 DelayedSingleton<CellularDataService>::GetInstance()->GetStateMachineCurrentStatusDump();
749 DelayedSingleton<CellularDataService>::GetInstance()->GetFlowDataInfoDump();
750 DelayedSingleton<CellularDataService>::GetInstance()->StrategySwitch(slotId, enable);
751 }
752
ChangeConnectionForDsdsFuzzTest(const uint8_t * data,size_t size)753 void ChangeConnectionForDsdsFuzzTest(const uint8_t *data, size_t size)
754 {
755 if (!IsServiceInited()) {
756 return;
757 }
758
759 FuzzedDataProvider fdp(data, size);
760 int32_t slotId = fdp.ConsumeIntegralInRange<uint32_t>(0, SLOT_NUM_MAX);
761 bool enable = fdp.ConsumeBool();
762 DelayedSingleton<CellularDataService>::GetInstance()->ChangeConnectionForDsds(slotId, enable);
763 DelayedSingleton<CellularDataService>::GetInstance()->GetSpendTime();
764 }
765
SendUrspDecodeResultFuzzTest(const uint8_t * data,size_t size)766 void SendUrspDecodeResultFuzzTest(const uint8_t *data, size_t size)
767 {
768 if (!IsServiceInited()) {
769 return;
770 }
771
772 FuzzedDataProvider fdp(data, size);
773 int32_t slotId = fdp.ConsumeIntegralInRange<uint32_t>(0, SLOT_NUM_MAX);
774 std::vector<ApnInfo> allApnInfoList;
775 DelayedSingleton<CellularDataService>::GetInstance()->QueryAllApnInfo(allApnInfoList);
776 std::vector<uint8_t> buffer;
777 DelayedSingleton<CellularDataService>::GetInstance()->SendUrspDecodeResult(slotId, buffer);
778 DelayedSingleton<CellularDataService>::GetInstance()->SendUePolicySectionIdentifier(slotId, buffer);
779 DelayedSingleton<CellularDataService>::GetInstance()->SendImsRsdList(slotId, buffer);
780 DelayedSingleton<CellularDataService>::GetInstance()->GetNetworkSliceAllowedNssai(slotId, buffer);
781 }
782
GetActiveApnNameFuzzTest(const uint8_t * data,size_t size)783 void GetActiveApnNameFuzzTest(const uint8_t *data, size_t size)
784 {
785 if (!IsServiceInited()) {
786 return;
787 }
788
789 FuzzedDataProvider fdp(data, size);
790 int32_t slotId = fdp.ConsumeIntegralInRange<uint32_t>(0, SLOT_NUM_MAX);
791 DelayedSingleton<CellularDataService>::GetInstance()->GetNetworkSliceEhplmn(slotId);
792 std::string apnName = fdp.ConsumeRandomLengthString(APN_STRING_LENGTH);
793 DelayedSingleton<CellularDataService>::GetInstance()->GetActiveApnName(apnName);
794 }
795
DoSomethingInterestingWithMyAPI(const uint8_t * data,size_t size)796 void DoSomethingInterestingWithMyAPI(const uint8_t *data, size_t size)
797 {
798 if (data == nullptr || size == 0) {
799 return;
800 }
801
802 EnableCellularData(data, size);
803 EnableIntelligenceSwitch(data, size);
804 GetCellularDataState(data, size);
805 IsCellularDataEnabled(data, size);
806 IsCellularDataRoamingEnabled(data, size);
807 GetDefaultCellularDataSlotId(data, size);
808 GetCellularDataFlowType(data, size);
809 EnableCellularDataRoaming(data, size);
810 SetDefaultCellularDataSlotId(data, size);
811 HasInternetCapability(data, size);
812 ClearCellularDataConnections(data, size);
813 RegisterSimAccountCallback(data, size);
814 UnregisterSimAccountCallback(data, size);
815 GetDefaultActReportInfo(data, size);
816 GetInternalActReportInfo(data, size);
817 HandleApnChanged(data, size);
818 GetDefaultCellularDataSimId(data, size);
819 ClearAllConnections(data, size);
820 GetDataConnApnAttr(data, size);
821 GetDataConnIpType(data, size);
822 GetApnState(data, size);
823 GetDataRecoveryState(data, size);
824 IsNeedDoRecovery(data, size);
825 InitCellularDataController(data, size);
826 EstablishAllApnsIfConnectable(data, size);
827 ReleaseCellularDataConnection(data, size);
828 GetSupplierRegisterState(data, size);
829 GetCellularDataSupplierId(data, size);
830 CorrectNetSupplierNoAvailable(data, size);
831 GetIfSupportDunApn(data, size);
832 QueryApnIds(data, size);
833 SetPreferApn(data, size);
834 ReleaseNetFuzzTest(data, size);
835 DumpFuzzTest(data, size);
836 DispatchEventFuzzTest(data, size);
837 StrategySwitchFuzzTest(data, size);
838 ChangeConnectionForDsdsFuzzTest(data, size);
839 SendUrspDecodeResultFuzzTest(data, size);
840 GetActiveApnNameFuzzTest(data, size);
841 }
842 } // namespace OHOS
843
844 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)845 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
846 {
847 OHOS::AddDataTokenFuzzer token;
848 /* Run your code on data */
849 OHOS::DoSomethingInterestingWithMyAPI(data, size);
850 OHOS::DelayedSingleton<CellularDataService>::DestroyInstance();
851 return 0;
852 }
853