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 "getcallrestriction_fuzzer.h"
17
18 #include <cstddef>
19 #include <cstdint>
20 #define private public
21 #include "addcellularcalltoken_fuzzer.h"
22 #include "cellular_call_service.h"
23 #include "securec.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 constexpr int32_t VEDIO_STATE_NUM = 2;
31 constexpr int32_t BOOL_NUM = 2;
32 constexpr size_t MAX_NUMBER_LEN = 99;
33
IsServiceInited()34 bool IsServiceInited()
35 {
36 DelayedSingleton<CellularCallService>::GetInstance()->OnStart();
37 if (!g_isInited && (static_cast<int32_t>(DelayedSingleton<CellularCallService>::GetInstance()->state_) ==
38 static_cast<int32_t>(ServiceRunningState::STATE_RUNNING))) {
39 g_isInited = true;
40 }
41 return g_isInited;
42 }
43
OnRemoteRequest(const uint8_t * data,size_t size)44 void OnRemoteRequest(const uint8_t *data, size_t size)
45 {
46 if (!IsServiceInited()) {
47 return;
48 }
49
50 MessageParcel dataMessageParcel;
51 if (!dataMessageParcel.WriteInterfaceToken(CellularCallStub::GetDescriptor())) {
52 return;
53 }
54 size_t dataSize = size - sizeof(uint32_t);
55 dataMessageParcel.WriteBuffer(data + sizeof(uint32_t), dataSize);
56 dataMessageParcel.RewindRead(0);
57 uint32_t code = static_cast<uint32_t>(size);
58 MessageParcel reply;
59 MessageOption option;
60 DelayedSingleton<CellularCallService>::GetInstance()->OnRemoteRequest(code, dataMessageParcel, reply, option);
61 }
62
UnRegisterCallManagerCallBack(const uint8_t * data,size_t size)63 void UnRegisterCallManagerCallBack(const uint8_t *data, size_t size)
64 {
65 if (!IsServiceInited()) {
66 return;
67 }
68
69 int32_t maxSize = static_cast<int32_t>(size);
70 MessageParcel dataMessageParcel;
71 dataMessageParcel.WriteInt32(maxSize);
72 size_t dataSize = size - sizeof(int32_t);
73 dataMessageParcel.WriteBuffer(data + sizeof(int32_t), dataSize);
74 dataMessageParcel.RewindRead(0);
75 MessageParcel reply;
76 DelayedSingleton<CellularCallService>::GetInstance()->OnUnRegisterCallBackInner(dataMessageParcel, reply);
77 }
78
IsEmergencyPhoneNumber(const uint8_t * data,size_t size)79 void IsEmergencyPhoneNumber(const uint8_t *data, size_t size)
80 {
81 if (!IsServiceInited()) {
82 return;
83 }
84
85 int32_t errorCode = static_cast<int32_t>(size);
86 std::string phoneNum(reinterpret_cast<const char *>(data), size);
87 MessageParcel dataMessageParcel;
88 dataMessageParcel.WriteInt32(errorCode);
89 dataMessageParcel.WriteString(phoneNum);
90 dataMessageParcel.RewindRead(0);
91 MessageParcel reply;
92 DelayedSingleton<CellularCallService>::GetInstance()->OnIsEmergencyPhoneNumberInner(dataMessageParcel, reply);
93 }
94
HangUpAllConnection(const uint8_t * data,size_t size)95 void HangUpAllConnection(const uint8_t *data, size_t size)
96 {
97 if (!IsServiceInited()) {
98 return;
99 }
100
101 int32_t maxSize = static_cast<int32_t>(size);
102 MessageParcel dataMessageParcel;
103 dataMessageParcel.WriteInt32(maxSize);
104 size_t dataSize = size - sizeof(int32_t);
105 dataMessageParcel.WriteBuffer(data + sizeof(int32_t), dataSize);
106 dataMessageParcel.RewindRead(0);
107 MessageParcel reply;
108 DelayedSingleton<CellularCallService>::GetInstance()->OnHangUpAllConnectionInner(dataMessageParcel, reply);
109 }
110
StartRtt(const uint8_t * data,size_t size)111 void StartRtt(const uint8_t *data, size_t size)
112 {
113 if (!IsServiceInited()) {
114 return;
115 }
116
117 std::string msg(reinterpret_cast<const char *>(data), size);
118 MessageParcel dataMessageParcel;
119 dataMessageParcel.WriteString(msg);
120 dataMessageParcel.RewindRead(0);
121 MessageParcel reply;
122 DelayedSingleton<CellularCallService>::GetInstance()->OnStartRttInner(dataMessageParcel, reply);
123 }
124
StopRtt(const uint8_t * data,size_t size)125 void StopRtt(const uint8_t *data, size_t size)
126 {
127 if (!IsServiceInited()) {
128 return;
129 }
130
131 MessageParcel dataMessageParcel;
132 dataMessageParcel.WriteBuffer(data, size);
133 dataMessageParcel.RewindRead(0);
134 MessageParcel reply;
135 DelayedSingleton<CellularCallService>::GetInstance()->OnStopRttInner(dataMessageParcel, reply);
136 }
137
GetCallTransferInfo(const uint8_t * data,size_t size)138 void GetCallTransferInfo(const uint8_t *data, size_t size)
139 {
140 if (!IsServiceInited()) {
141 return;
142 }
143
144 int32_t type = static_cast<int32_t>(size);
145 MessageParcel dataMessageParcel;
146 dataMessageParcel.WriteInt32(type);
147 size_t dataSize = size - sizeof(int32_t);
148 dataMessageParcel.WriteBuffer(data + sizeof(int32_t), dataSize);
149 dataMessageParcel.RewindRead(0);
150 MessageParcel reply;
151 DelayedSingleton<CellularCallService>::GetInstance()->OnGetCallTransferInner(dataMessageParcel, reply);
152 }
153
GetCallWaiting(const uint8_t * data,size_t size)154 void GetCallWaiting(const uint8_t *data, size_t size)
155 {
156 if (!IsServiceInited()) {
157 return;
158 }
159
160 MessageParcel dataMessageParcel;
161 dataMessageParcel.WriteBuffer(data, size);
162 dataMessageParcel.RewindRead(0);
163 MessageParcel reply;
164 DelayedSingleton<CellularCallService>::GetInstance()->OnGetCallWaitingInner(dataMessageParcel, reply);
165 }
166
SetCallWaiting(const uint8_t * data,size_t size)167 void SetCallWaiting(const uint8_t *data, size_t size)
168 {
169 if (!IsServiceInited()) {
170 return;
171 }
172
173 int32_t activate = static_cast<int32_t>(size % BOOL_NUM);
174 MessageParcel dataMessageParcel;
175 dataMessageParcel.WriteBool(activate);
176 dataMessageParcel.RewindRead(0);
177 MessageParcel reply;
178 DelayedSingleton<CellularCallService>::GetInstance()->OnSetCallWaitingInner(dataMessageParcel, reply);
179 }
180
GetCallRestriction(const uint8_t * data,size_t size)181 void GetCallRestriction(const uint8_t *data, size_t size)
182 {
183 if (!IsServiceInited()) {
184 return;
185 }
186
187 int32_t facType = static_cast<int32_t>(size);
188 MessageParcel dataMessageParcel;
189 dataMessageParcel.WriteInt32(facType);
190 size_t dataSize = size - sizeof(int32_t);
191 dataMessageParcel.WriteBuffer(data + sizeof(int32_t), dataSize);
192 dataMessageParcel.RewindRead(0);
193 MessageParcel reply;
194 DelayedSingleton<CellularCallService>::GetInstance()->OnGetCallRestrictionInner(dataMessageParcel, reply);
195 }
196
Dial(const uint8_t * data,size_t size)197 void Dial(const uint8_t *data, size_t size)
198 {
199 if (!IsServiceInited()) {
200 return;
201 }
202
203 int32_t maxSize = static_cast<int32_t>(size);
204 int32_t slotId = static_cast<int32_t>(size % SLOT_NUM);
205 int32_t callId = static_cast<int32_t>(size);
206 int32_t accountId = static_cast<int32_t>(size);
207 int32_t videoState = static_cast<int32_t>(size % VEDIO_STATE_NUM);
208 int32_t index = static_cast<int32_t>(size);
209 std::string telNum = "000000000";
210 std::string tempNum(reinterpret_cast<const char *>(data), size);
211 if (strlen(tempNum.c_str()) <= MAX_NUMBER_LEN) {
212 telNum = tempNum;
213 }
214 size_t length = strlen(telNum.c_str()) + 1;
215 CellularCallInfo callInfo;
216 callInfo.slotId = slotId;
217 callInfo.callId = callId;
218 callInfo.accountId = accountId;
219 callInfo.videoState = videoState;
220 callInfo.index = index;
221 if (strcpy_s(callInfo.phoneNum, length, telNum.c_str()) != EOK) {
222 return;
223 }
224 MessageParcel dataMessageParcel;
225 dataMessageParcel.WriteInt32(maxSize);
226 dataMessageParcel.WriteRawData(static_cast<const void *>(&callInfo), sizeof(CellularCallInfo));
227 dataMessageParcel.RewindRead(0);
228 MessageParcel reply;
229 DelayedSingleton<CellularCallService>::GetInstance()->OnDialInner(dataMessageParcel, reply);
230 }
231
InviteToConference(const uint8_t * data,size_t size)232 void InviteToConference(const uint8_t *data, size_t size)
233 {
234 if (!IsServiceInited()) {
235 return;
236 }
237
238 std::string number(reinterpret_cast<const char *>(data), size);
239 std::vector<std::string> numberList;
240 numberList.push_back(number);
241 MessageParcel dataMessageParcel;
242 dataMessageParcel.WriteStringVector(numberList);
243 dataMessageParcel.RewindRead(0);
244 MessageParcel reply;
245 DelayedSingleton<CellularCallService>::GetInstance()->OnInviteToConferenceInner(dataMessageParcel, reply);
246 }
247
KickOutFromConference(const uint8_t * data,size_t size)248 void KickOutFromConference(const uint8_t *data, size_t size)
249 {
250 if (!IsServiceInited()) {
251 return;
252 }
253
254 std::string number(reinterpret_cast<const char *>(data), size);
255 std::vector<std::string> numberList;
256 numberList.push_back(number);
257 MessageParcel dataMessageParcel;
258 dataMessageParcel.WriteStringVector(numberList);
259 dataMessageParcel.RewindRead(0);
260 MessageParcel reply;
261 DelayedSingleton<CellularCallService>::GetInstance()->OnKickOutFromConferenceInner(dataMessageParcel, reply);
262 }
263
DoSomethingInterestingWithMyAPI(const uint8_t * data,size_t size)264 void DoSomethingInterestingWithMyAPI(const uint8_t *data, size_t size)
265 {
266 if (data == nullptr || size == 0) {
267 return;
268 }
269
270 OnRemoteRequest(data, size);
271 UnRegisterCallManagerCallBack(data, size);
272 IsEmergencyPhoneNumber(data, size);
273 HangUpAllConnection(data, size);
274 StartRtt(data, size);
275 StopRtt(data, size);
276 GetCallTransferInfo(data, size);
277 GetCallWaiting(data, size);
278 SetCallWaiting(data, size);
279 GetCallRestriction(data, size);
280 Dial(data, size);
281 InviteToConference(data, size);
282 KickOutFromConference(data, size);
283 return;
284 }
285 } // namespace OHOS
286
287 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)288 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
289 {
290 OHOS::AddCellularCallTokenFuzzer token;
291 /* Run your code on data */
292 OHOS::DoSomethingInterestingWithMyAPI(data, size);
293 return 0;
294 }
295