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