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