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 "registercallmanagercallback_fuzzer.h"
17
18 #include <cstddef>
19 #include <cstdint>
20 #define private public
21 #include "addcellularcalltoken_fuzzer.h"
22 #include "cellular_call_register.h"
23 #include "cellular_call_service.h"
24 #include "hril_call_parcel.h"
25 #include "radio_event.h"
26 #include "securec.h"
27 #include "system_ability_definition.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 BOOL_NUM = 2;
34 constexpr int32_t CALL_STATE_NUM = 8;
35 constexpr int32_t EVENT_ID_NUM = 20;
36
IsServiceInited()37 bool IsServiceInited()
38 {
39 DelayedSingleton<CellularCallService>::GetInstance()->OnStart();
40 if (!g_isInited && (static_cast<int32_t>(DelayedSingleton<CellularCallService>::GetInstance()->state_) ==
41 static_cast<int32_t>(ServiceRunningState::STATE_RUNNING))) {
42 g_isInited = true;
43 }
44 return g_isInited;
45 }
46
ReportCallsInfo(const uint8_t * data,size_t size)47 void ReportCallsInfo(const uint8_t *data, size_t size)
48 {
49 if (!IsServiceInited()) {
50 return;
51 }
52
53 std::shared_ptr<CellularCallRegister> cellularCallRegister = DelayedSingleton<CellularCallRegister>::GetInstance();
54 CallsReportInfo callsReportInfo;
55 callsReportInfo.slotId = static_cast<int32_t>(size % SLOT_NUM);
56 CallReportInfo callReportInfo;
57 std::string number(reinterpret_cast<const char *>(data), size);
58 int32_t length = number.length() > kMaxNumberLen ? kMaxNumberLen : number.length();
59 if (memcpy_s(callReportInfo.accountNum, kMaxNumberLen, number.c_str(), length) != EOK) {
60 return;
61 }
62 sptr<ICallStatusCallback> callback = nullptr;
63 TelCallState callState = static_cast<TelCallState>(size % CALL_STATE_NUM);
64 CellularCallEventInfo info;
65 info.eventType = CellularCallEventType::EVENT_REQUEST_RESULT_TYPE;
66 info.eventId = static_cast<RequestResultEventId>(size % EVENT_ID_NUM);
67 CallWaitResponse response;
68 response.classCw = static_cast<int32_t>(size);
69 response.result = static_cast<int32_t>(size % BOOL_NUM);
70 response.status = static_cast<int32_t>(size % BOOL_NUM);
71 int32_t result = static_cast<int32_t>(size % BOOL_NUM);
72 CallRestrictionResponse callRestrictionResponse;
73 callRestrictionResponse.classCw = static_cast<int32_t>(size);
74 callRestrictionResponse.result = static_cast<int32_t>(size % BOOL_NUM);
75 callRestrictionResponse.status = static_cast<int32_t>(size % BOOL_NUM);
76
77 cellularCallRegister->ReportCallsInfo(callsReportInfo);
78 cellularCallRegister->RegisterCallManagerCallBack(callback);
79 cellularCallRegister->ReportSingleCallInfo(callReportInfo, callState);
80 cellularCallRegister->UnRegisterCallManagerCallBack();
81 cellularCallRegister->ReportEventResultInfo(info);
82 cellularCallRegister->ReportGetWaitingResult(response);
83 cellularCallRegister->ReportSetWaitingResult(result);
84 cellularCallRegister->ReportGetRestrictionResult(callRestrictionResponse);
85 }
86
ReportSetRestrictionResult(const uint8_t * data,size_t size)87 void ReportSetRestrictionResult(const uint8_t *data, size_t size)
88 {
89 if (!IsServiceInited()) {
90 return;
91 }
92
93 std::shared_ptr<CellularCallRegister> cellularCallRegister = DelayedSingleton<CellularCallRegister>::GetInstance();
94 int32_t result = static_cast<int32_t>(size % BOOL_NUM);
95 CallTransferResponse callTransferResponse;
96 callTransferResponse.result = static_cast<int32_t>(size);
97 callTransferResponse.status = static_cast<int32_t>(size);
98 callTransferResponse.classx = static_cast<int32_t>(size);
99 callTransferResponse.type = static_cast<int32_t>(size);
100 callTransferResponse.time = static_cast<int32_t>(size);
101 callTransferResponse.reason = static_cast<int32_t>(size);
102 std::string number(reinterpret_cast<const char *>(data), size);
103 int32_t length = number.length() > kMaxNumberLen ? kMaxNumberLen : number.length();
104 if (memcpy_s(callTransferResponse.number, kMaxNumberLen, number.c_str(), length) != EOK) {
105 return;
106 }
107 ClipResponse clipResponse;
108 clipResponse.action = static_cast<int32_t>(size);
109 clipResponse.result = static_cast<int32_t>(size);
110 clipResponse.clipStat = static_cast<int32_t>(size);
111 ClirResponse clirResponse;
112 clirResponse.clirStat = static_cast<int32_t>(size);
113 clirResponse.action = static_cast<int32_t>(size);
114 clirResponse.result = static_cast<int32_t>(size);
115 GetImsConfigResponse getImsConfigResponse;
116 getImsConfigResponse.result = static_cast<int32_t>(size);
117 getImsConfigResponse.value = static_cast<int32_t>(size);
118
119 cellularCallRegister->ReportSetRestrictionResult(result);
120 cellularCallRegister->ReportGetTransferResult(callTransferResponse);
121 cellularCallRegister->ReportSetTransferResult(result);
122 cellularCallRegister->ReportGetClipResult(clipResponse);
123 cellularCallRegister->ReportGetClirResult(clirResponse);
124 cellularCallRegister->ReportSetClirResult(result);
125 cellularCallRegister->ReportGetImsConfigResult(getImsConfigResponse);
126 cellularCallRegister->ReportSetImsConfigResult(result);
127 cellularCallRegister->ReportSetImsFeatureResult(result);
128 }
129
ReportSetImsConfigResult(const uint8_t * data,size_t size)130 void ReportSetImsConfigResult(const uint8_t *data, size_t size)
131 {
132 if (!IsServiceInited()) {
133 return;
134 }
135
136 std::shared_ptr<CellularCallRegister> cellularCallRegister = DelayedSingleton<CellularCallRegister>::GetInstance();
137 int32_t result = static_cast<int32_t>(size % BOOL_NUM);
138 GetImsFeatureValueResponse getImsFeatureValueResponse;
139 getImsFeatureValueResponse.result = static_cast<int32_t>(size);
140 getImsFeatureValueResponse.value = static_cast<int32_t>(size);
141 GetLteEnhanceModeResponse getLteEnhanceModeResponse;
142 getLteEnhanceModeResponse.result = static_cast<int32_t>(size);
143 getLteEnhanceModeResponse.value = static_cast<int32_t>(size);
144 DisconnectedDetails details;
145 std::string number(reinterpret_cast<const char *>(data), size);
146 details.message = number;
147 details.reason = static_cast<DisconnectedReason>(size);
148 MuteControlResponse muteControlResponse;
149 muteControlResponse.result = static_cast<int32_t>(size);
150 muteControlResponse.value = static_cast<int32_t>(size);
151 SetEccListResponse setEccListResponse;
152 setEccListResponse.result = static_cast<int32_t>(size);
153 setEccListResponse.value = static_cast<int32_t>(size);
154 MmiCodeInfo mmiCodeInfo;
155 mmiCodeInfo.result = static_cast<int32_t>(size);
156 int32_t length = number.length() > kMaxNumberLen ? kMaxNumberLen : number.length();
157 if (memcpy_s(mmiCodeInfo.message, kMaxNumberLen, number.c_str(), length) != EOK) {
158 return;
159 }
160
161 cellularCallRegister->ReportGetImsFeatureResult(getImsFeatureValueResponse);
162 cellularCallRegister->ReportCallRingBackResult(result);
163 cellularCallRegister->ReportCallFailReason(details);
164 cellularCallRegister->ReportGetMuteResult(muteControlResponse);
165 cellularCallRegister->ReportSetMuteResult(muteControlResponse);
166 cellularCallRegister->ReportInviteToConferenceResult(result);
167 cellularCallRegister->ReportUpdateCallMediaModeResult(result);
168 cellularCallRegister->ReportGetCallDataResult(result);
169 cellularCallRegister->ReportStartDtmfResult(result);
170 cellularCallRegister->ReportStopDtmfResult(result);
171 cellularCallRegister->ReportStartRttResult(result);
172 cellularCallRegister->ReportStopRttResult(result);
173 cellularCallRegister->ReportSendUssdResult(result);
174 cellularCallRegister->ReportMmiCodeResult(mmiCodeInfo);
175 cellularCallRegister->ReportSetEmergencyCallListResponse(setEccListResponse);
176 cellularCallRegister->IsCallManagerCallBackRegistered();
177 }
178
DoSomethingInterestingWithMyAPI(const uint8_t * data,size_t size)179 void DoSomethingInterestingWithMyAPI(const uint8_t *data, size_t size)
180 {
181 if (data == nullptr || size == 0) {
182 return;
183 }
184
185 ReportCallsInfo(data, size);
186 ReportSetRestrictionResult(data, size);
187 ReportSetImsConfigResult(data, size);
188 }
189 } // namespace OHOS
190
191 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)192 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
193 {
194 OHOS::AddCellularCallTokenFuzzer token;
195 /* Run your code on data */
196 OHOS::DoSomethingInterestingWithMyAPI(data, size);
197 return 0;
198 }
199