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 "updateiccdiallingnumbers_fuzzer.h"
17
18 #include <cstddef>
19 #include <cstdint>
20 #include <thread>
21
22 #define private public
23 #include "addcoreservicetoken_fuzzer.h"
24 #include "core_service.h"
25 #include "napi_util.h"
26 #include "system_ability_definition.h"
27 #include "unistd.h"
28
29 using namespace OHOS::Telephony;
30 namespace OHOS {
31 static bool g_isInited = false;
32 constexpr int32_t SLOT_NUM = 2;
33 constexpr int32_t ACCEPT_TYPE = 2;
34 constexpr int32_t SIM_TYPE_NUM = 2;
35 constexpr int32_t SLEEP_TIME_SECONDS = 2;
36
IsServiceInited()37 bool IsServiceInited()
38 {
39 if (!g_isInited) {
40 auto onStart = [] { DelayedSingleton<CoreService>::GetInstance()->OnStart(); };
41 std::thread startThread(onStart);
42 pthread_setname_np(startThread.native_handle(), "updateiccdiallingnumbers_fuzzer");
43 startThread.join();
44
45 sleep(SLEEP_TIME_SECONDS);
46 if (DelayedSingleton<CoreService>::GetInstance()->GetServiceRunningState() ==
47 static_cast<int32_t>(ServiceRunningState::STATE_RUNNING)) {
48 g_isInited = true;
49 }
50 }
51 return g_isInited;
52 }
53
GetOpKey(const uint8_t * data,size_t size)54 void GetOpKey(const uint8_t *data, size_t size)
55 {
56 if (!IsServiceInited()) {
57 return;
58 }
59
60 int32_t slotId = static_cast<int32_t>(size % SLOT_NUM);
61 MessageParcel dataMessageParcel;
62 dataMessageParcel.WriteInt32(slotId);
63 dataMessageParcel.WriteBuffer(data, size);
64 dataMessageParcel.RewindRead(0);
65 MessageParcel reply;
66 DelayedSingleton<CoreService>::GetInstance()->OnGetOpKey(dataMessageParcel, reply);
67 }
68
GetOpKeyExt(const uint8_t * data,size_t size)69 void GetOpKeyExt(const uint8_t *data, size_t size)
70 {
71 if (!IsServiceInited()) {
72 return;
73 }
74
75 int32_t slotId = static_cast<int32_t>(size % SLOT_NUM);
76 MessageParcel dataMessageParcel;
77 dataMessageParcel.WriteInt32(slotId);
78
79 dataMessageParcel.WriteBuffer(data, size);
80 dataMessageParcel.RewindRead(0);
81 MessageParcel reply;
82 DelayedSingleton<CoreService>::GetInstance()->OnGetOpKeyExt(dataMessageParcel, reply);
83 }
84
GetOpName(const uint8_t * data,size_t size)85 void GetOpName(const uint8_t *data, size_t size)
86 {
87 if (!IsServiceInited()) {
88 return;
89 }
90
91 int32_t slotId = static_cast<int32_t>(size % SLOT_NUM);
92 MessageParcel dataMessageParcel;
93 dataMessageParcel.WriteInt32(slotId);
94
95 dataMessageParcel.WriteBuffer(data, size);
96 dataMessageParcel.RewindRead(0);
97 MessageParcel reply;
98 DelayedSingleton<CoreService>::GetInstance()->OnGetOpName(dataMessageParcel, reply);
99 }
100
SendCallSetupRequestResult(const uint8_t * data,size_t size)101 void SendCallSetupRequestResult(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 int32_t accept = static_cast<int32_t>(size % ACCEPT_TYPE);
109 MessageParcel dataMessageParcel;
110 dataMessageParcel.WriteInt32(slotId);
111 dataMessageParcel.WriteInt32(accept);
112
113 dataMessageParcel.WriteBuffer(data, size);
114 dataMessageParcel.RewindRead(0);
115 MessageParcel reply;
116 DelayedSingleton<CoreService>::GetInstance()->OnSendCallSetupRequestResult(dataMessageParcel, reply);
117 }
118
HasOperatorPrivileges(const uint8_t * data,size_t size)119 void HasOperatorPrivileges(const uint8_t *data, size_t size)
120 {
121 if (!IsServiceInited()) {
122 return;
123 }
124
125 int32_t slotId = static_cast<int32_t>(size % SLOT_NUM);
126 MessageParcel dataMessageParcel;
127 dataMessageParcel.WriteInt32(slotId);
128
129 dataMessageParcel.WriteBuffer(data, size);
130 dataMessageParcel.RewindRead(0);
131 MessageParcel reply;
132 DelayedSingleton<CoreService>::GetInstance()->OnHasOperatorPrivileges(dataMessageParcel, reply);
133 }
134
GetCellInfoList(const uint8_t * data,size_t size)135 void GetCellInfoList(const uint8_t *data, size_t size)
136 {
137 if (!IsServiceInited()) {
138 return;
139 }
140
141 int32_t slotId = static_cast<int32_t>(size % SLOT_NUM);
142 MessageParcel dataMessageParcel;
143 dataMessageParcel.WriteInt32(slotId);
144
145 dataMessageParcel.WriteBuffer(data, size);
146 dataMessageParcel.RewindRead(0);
147 MessageParcel reply;
148 DelayedSingleton<CoreService>::GetInstance()->OnGetCellInfoList(dataMessageParcel, reply);
149 }
150
UpdateIccDiallingNumbers(const uint8_t * data,size_t size)151 void UpdateIccDiallingNumbers(const uint8_t *data, size_t size)
152 {
153 if (!IsServiceInited()) {
154 return;
155 }
156
157 int32_t slotId = static_cast<int32_t>(size % SLOT_NUM);
158 int32_t type = size % SIM_TYPE_NUM + 1;
159 MessageParcel dataMessageParcel;
160 dataMessageParcel.WriteInt32(slotId);
161 dataMessageParcel.WriteInt32(type);
162 dataMessageParcel.WriteBuffer(data, size);
163 dataMessageParcel.RewindRead(0);
164 MessageParcel reply;
165 DelayedSingleton<CoreService>::GetInstance()->OnUpdateIccDiallingNumbers(dataMessageParcel, reply);
166 }
167
GetNrSsbIdInfoTesting(const uint8_t * data,size_t size)168 void GetNrSsbIdInfoTesting(const uint8_t *data, size_t size)
169 {
170 if (!IsServiceInited()) {
171 return;
172 }
173
174 int32_t slotId = static_cast<int32_t>(size % SLOT_NUM);
175 MessageParcel dataMessageParcel;
176 dataMessageParcel.WriteInt32(slotId);
177
178 dataMessageParcel.WriteBuffer(data, size);
179 dataMessageParcel.RewindRead(0);
180 MessageParcel reply;
181 DelayedSingleton<CoreService>::GetInstance()->OnGetNrSsbIdInfo(dataMessageParcel, reply);
182 }
183
DoSomethingInterestingWithMyAPI(const uint8_t * data,size_t size)184 void DoSomethingInterestingWithMyAPI(const uint8_t *data, size_t size)
185 {
186 if (data == nullptr || size == 0) {
187 return;
188 }
189
190 GetOpKey(data, size);
191 GetOpKeyExt(data, size);
192 GetOpName(data, size);
193 SendCallSetupRequestResult(data, size);
194 HasOperatorPrivileges(data, size);
195 GetCellInfoList(data, size);
196 UpdateIccDiallingNumbers(data, size);
197 GetNrSsbIdInfoTesting(data, size);
198 auto telRilManager = DelayedSingleton<CoreService>::GetInstance()->telRilManager_;
199 if (telRilManager == nullptr) {
200 return;
201 }
202 auto handler = telRilManager->handler_;
203 if (handler != nullptr) {
204 handler->RemoveAllEvents();
205 handler->SendEvent(0, 0, AppExecFwk::EventQueue::Priority::HIGH);
206 sleep(SLEEP_TIME_SECONDS);
207 }
208 return;
209 }
210 } // namespace OHOS
211
212 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)213 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
214 {
215 OHOS::AddCoreServiceTokenFuzzer token;
216 /* Run your code on data */
217 OHOS::DoSomethingInterestingWithMyAPI(data, size);
218 return 0;
219 }
220