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 "call_fuzzer.h"
17 
18 #include <cstddef>
19 #include <cstdint>
20 #define private public
21 #define protected public
22 #include "addcalltoken_fuzzer.h"
23 #include "cs_call.h"
24 #include "ims_call.h"
25 #include "ott_call.h"
26 #include "satellite_call.h"
27 #include "surface_utils.h"
28 #include "voip_call.h"
29 
30 using namespace OHOS::Telephony;
31 namespace OHOS {
32 constexpr int32_t SLOT_NUM = 2;
33 constexpr int32_t BOOL_NUM = 2;
34 constexpr int32_t DIAL_TYPE = 3;
35 constexpr int32_t CALL_TYPE_NUM = 4;
36 constexpr int32_t VIDIO_TYPE_NUM = 2;
37 constexpr int32_t TEL_CALL_STATE_NUM = 9;
38 constexpr int32_t TEL_CONFERENCE_STATE_NUM = 4;
39 constexpr int32_t CALL_RUNNING_STATE_NUM = 8;
40 constexpr int32_t CALL_ENDED_TYPE_NUM = 4;
41 constexpr int32_t CALL_ANSWER_TYPE_NUM = 3;
42 constexpr int32_t INVALID_CALL_ID = -1;
43 constexpr int32_t IMS_CALL_MODE_NUM = 5;
44 constexpr int32_t CALL_INDEX_MAX_NUM = 8;
45 constexpr int32_t VIDEO_REQUEST_RESULT_TYPE_NUM = 102;
46 
CSCallFunc(const uint8_t * data,size_t size)47 void CSCallFunc(const uint8_t *data, size_t size)
48 {
49     if (!IsServiceInited()) {
50         return;
51     }
52 
53     DialParaInfo dialParaInfo;
54     dialParaInfo.dialType = static_cast<DialType>(size % DIAL_TYPE);
55     dialParaInfo.callType = static_cast<CallType>(size % CALL_TYPE_NUM);
56     dialParaInfo.videoState = static_cast<VideoStateType>(size % VIDIO_TYPE_NUM);
57     dialParaInfo.callState = static_cast<TelCallState>(size % TEL_CALL_STATE_NUM);
58     sptr<CallBase> callObjectPtr = std::make_unique<CSCall>(dialParaInfo).release();
59     int32_t videoState = static_cast<int32_t>(size % VIDIO_TYPE_NUM);
60     int32_t mute = static_cast<int32_t>(size % BOOL_NUM);
61     int32_t slotId = static_cast<int32_t>(size % SLOT_NUM);
62     TelCallState nextState = static_cast<TelCallState>(size % TEL_CALL_STATE_NUM);
63     TelConferenceState telConferenceState = static_cast<TelConferenceState>(size % TEL_CONFERENCE_STATE_NUM);
64     VideoStateType mediaType = static_cast<VideoStateType>(size % VIDIO_TYPE_NUM);
65     PolicyFlag flag = static_cast<PolicyFlag>(size);
66     bool needAutoAnswer = static_cast<bool>(size);
67     bool canUnHoldState = static_cast<bool>(size);
68 
69     callObjectPtr->AnswerCall(videoState);
70     callObjectPtr->SetMute(mute, slotId);
71     callObjectPtr->StartDtmf(static_cast<char>(*data));
72     callObjectPtr->StopDtmf();
73     callObjectPtr->GetSlotId();
74     callObjectPtr->DialCallBase();
75     callObjectPtr->IncomingCallBase();
76     callObjectPtr->AnswerCallBase();
77     callObjectPtr->RejectCallBase();
78     callObjectPtr->GetCallID();
79     callObjectPtr->GetCallType();
80     callObjectPtr->GetCallRunningState();
81     callObjectPtr->SetTelCallState(nextState);
82     callObjectPtr->GetTelCallState();
83     callObjectPtr->SetTelConferenceState(telConferenceState);
84     callObjectPtr->GetTelConferenceState();
85     callObjectPtr->GetVideoStateType();
86     callObjectPtr->SetVideoStateType(mediaType);
87     callObjectPtr->SetPolicyFlag(flag);
88     callObjectPtr->GetPolicyFlag();
89     callObjectPtr->SetAutoAnswerState(needAutoAnswer);
90     callObjectPtr->GetAutoAnswerState();
91     callObjectPtr->SetCanUnHoldState(canUnHoldState);
92     callObjectPtr->GetCanUnHoldState();
93 }
94 
DialingProcess(const uint8_t * data,size_t size)95 void DialingProcess(const uint8_t *data, size_t size)
96 {
97     if (!IsServiceInited()) {
98         return;
99     }
100 
101     DialParaInfo paraInfo;
102     paraInfo.dialType = static_cast<DialType>(size % DIAL_TYPE);
103     paraInfo.callType = static_cast<CallType>(size % CALL_TYPE_NUM);
104     paraInfo.videoState = static_cast<VideoStateType>(size % VIDIO_TYPE_NUM);
105     paraInfo.callState = static_cast<TelCallState>(size % TEL_CALL_STATE_NUM);
106     sptr<CallBase> callObjectPtr = std::make_unique<CSCall>(paraInfo).release();
107 
108     callObjectPtr->StartDtmf(static_cast<char>(*data));
109     callObjectPtr->RejectCall();
110     callObjectPtr->HangUpCall();
111     callObjectPtr->HoldCall();
112     callObjectPtr->UnHoldCall();
113     callObjectPtr->SwitchCall();
114     callObjectPtr->DialingProcess();
115     callObjectPtr->CombineConference(); // merge calls
116     callObjectPtr->SeparateConference();
117     callObjectPtr->KickOutFromConference();
118     callObjectPtr->CanSeparateConference();
119     callObjectPtr->CanCombineConference();
120     callObjectPtr->CanKickOutFromConference();
121     callObjectPtr->LaunchConference();
122     callObjectPtr->ExitConference();
123     callObjectPtr->HoldConference();
124     int32_t mainCallId = INVALID_CALL_ID;
125     callObjectPtr->GetMainCallId(mainCallId);
126     std::vector<std::u16string> subCallIdList;
127     callObjectPtr->GetSubCallIdList(subCallIdList);
128     std::vector<std::u16string> callIdList;
129     callObjectPtr->GetCallIdListForConference(callIdList);
130     callObjectPtr->IsSupportConferenceable();
131     callObjectPtr->GetEmergencyState();
132 }
133 
GetCallerInfo(const uint8_t * data,size_t size)134 void GetCallerInfo(const uint8_t *data, size_t size)
135 {
136     if (!IsServiceInited()) {
137         return;
138     }
139 
140     DialParaInfo info;
141     info.dialType = static_cast<DialType>(size % DIAL_TYPE);
142     info.callType = static_cast<CallType>(size % CALL_TYPE_NUM);
143     info.videoState = static_cast<VideoStateType>(size % VIDIO_TYPE_NUM);
144     info.callState = static_cast<TelCallState>(size % TEL_CALL_STATE_NUM);
145     sptr<CallBase> callObjectPtr = std::make_unique<CSCall>(info).release();
146     ContactInfo contactInfo;
147     CallRunningState callRunningState = static_cast<CallRunningState>(size % CALL_RUNNING_STATE_NUM);
148     bool speakerphoneOn = static_cast<bool>(size % BOOL_NUM);
149     std::string phoneNumber(reinterpret_cast<const char *>(data), size);
150     int32_t callId = static_cast<int32_t>(size);
151     CallEndedType callEndedType = static_cast<CallEndedType>(size % CALL_ENDED_TYPE_NUM);
152     CallAnswerType answerType = static_cast<CallAnswerType>(size % CALL_ANSWER_TYPE_NUM);
153     int64_t startTime = static_cast<int64_t>(size);
154     time_t callBeginTime = static_cast<time_t>(size);
155     time_t callCreateTime = static_cast<time_t>(size);
156     time_t callEndTime = static_cast<time_t>(size);
157     time_t ringBeginTime = static_cast<time_t>(size);
158     time_t ringEndTime = static_cast<time_t>(size);
159     callObjectPtr->GetCallerInfo();
160     callObjectPtr->SetCallerInfo(contactInfo);
161     callObjectPtr->SetCallRunningState(callRunningState);
162     callObjectPtr->SetStartTime(startTime);
163     callObjectPtr->SetCallBeginTime(callBeginTime);
164     callObjectPtr->SetCallBeginTime(callCreateTime);
165     callObjectPtr->SetCallEndTime(callEndTime);
166     callObjectPtr->SetRingBeginTime(ringBeginTime);
167     callObjectPtr->SetRingEndTime(ringEndTime);
168     callObjectPtr->SetAnswerType(answerType);
169     callObjectPtr->GetCallEndedType();
170     callObjectPtr->SetCallEndedType(callEndedType);
171     callObjectPtr->SetCallId(callId);
172     callObjectPtr->IsSpeakerphoneEnabled();
173     callObjectPtr->IsCurrentRinging();
174     callObjectPtr->GetAccountNumber();
175     callObjectPtr->SetSpeakerphoneOn(speakerphoneOn);
176     callObjectPtr->IsSpeakerphoneOn();
177     callObjectPtr->CheckVoicemailNumber(phoneNumber);
178     callObjectPtr->IsAliveState();
179 }
180 
IMSCallFunc(const uint8_t * data,size_t size)181 void IMSCallFunc(const uint8_t *data, size_t size)
182 {
183     if (!IsServiceInited()) {
184         return;
185     }
186 
187     DialParaInfo paraInfo;
188     paraInfo.dialType = static_cast<DialType>(size % DIAL_TYPE);
189     paraInfo.callType = static_cast<CallType>(size % CALL_TYPE_NUM);
190     paraInfo.videoState = static_cast<VideoStateType>(size % VIDIO_TYPE_NUM);
191     paraInfo.callState = static_cast<TelCallState>(size % TEL_CALL_STATE_NUM);
192     sptr<IMSCall> callObjectPtr = std::make_unique<IMSCall>(paraInfo).release();
193     int32_t videoState = static_cast<int32_t>(size % VIDIO_TYPE_NUM);
194     int32_t mute = static_cast<int32_t>(size % BOOL_NUM);
195     int32_t slotId = static_cast<int32_t>(size % SLOT_NUM);
196     std::string msg(reinterpret_cast<const char *>(data), size);
197     std::u16string msgU16 = Str8ToStr16(msg);
198 
199     callObjectPtr->InitVideoCall();
200     callObjectPtr->DialingProcess();
201     callObjectPtr->AnswerCall(videoState);
202     callObjectPtr->RejectCall();
203     callObjectPtr->HangUpCall();
204     callObjectPtr->UnHoldCall();
205     callObjectPtr->HoldCall();
206     callObjectPtr->SwitchCall();
207     callObjectPtr->CombineConference();
208     callObjectPtr->SeparateConference();
209     callObjectPtr->KickOutFromConference();
210     callObjectPtr->CanKickOutFromConference();
211     callObjectPtr->CanCombineConference();
212     callObjectPtr->CanSeparateConference();
213     callObjectPtr->LaunchConference();
214     callObjectPtr->ExitConference();
215     callObjectPtr->HoldConference();
216     int32_t mainCallId = INVALID_CALL_ID;
217     callObjectPtr->GetMainCallId(mainCallId);
218     std::vector<std::u16string> subCallIdList;
219     callObjectPtr->GetSubCallIdList(subCallIdList);
220     std::vector<std::u16string> callIdList;
221     callObjectPtr->GetCallIdListForConference(callIdList);
222     callObjectPtr->IsSupportConferenceable();
223     callObjectPtr->StartRtt(msgU16);
224     callObjectPtr->StopRtt();
225     callObjectPtr->SetMute(mute, slotId);
226 }
227 
VoIPCallFunc(const uint8_t * data,size_t size)228 void VoIPCallFunc(const uint8_t *data, size_t size)
229 {
230     if (!IsServiceInited()) {
231         return;
232     }
233     CallAttributeInfo info;
234     DialParaInfo dialParaInfo;
235     int32_t mainCallId = 0;
236     VoipCallEventInfo voipcallInfo;
237     std::vector<std::u16string> callIdList;
238     int32_t videoState = static_cast<int32_t>(size % VIDIO_TYPE_NUM);
239     sptr<VoIPCall> voipCall = std::make_unique<VoIPCall>(dialParaInfo).release();
240 
241     voipCall->DialingProcess();
242     voipCall->AnswerCall(videoState);
243     voipCall->PackVoipCallInfo(voipcallInfo);
244     voipCall->RejectCall();
245     voipCall->HangUpCall();
246     voipCall->HoldCall();
247     voipCall->UnHoldCall();
248     voipCall->SwitchCall();
249     voipCall->SetMute(0, 0);
250     voipCall->GetCallAttributeInfo(info);
251     voipCall->CombineConference();
252     voipCall->HandleCombineConferenceFailEvent();
253     voipCall->SeparateConference();
254     voipCall->KickOutFromConference();
255     voipCall->CanCombineConference();
256     voipCall->CanSeparateConference();
257     voipCall->CanKickOutFromConference();
258     voipCall->GetMainCallId(mainCallId);
259     voipCall->GetSubCallIdList(callIdList);
260     voipCall->GetCallIdListForConference(callIdList);
261     voipCall->IsSupportConferenceable();
262     voipCall->LaunchConference();
263     voipCall->ExitConference();
264     voipCall->HoldConference();
265 }
266 
IMSVideoCallFunc(const uint8_t * data,size_t size)267 void IMSVideoCallFunc(const uint8_t *data, size_t size)
268 {
269     if (!IsServiceInited()) {
270         return;
271     }
272 
273     DialParaInfo paraInfo;
274     paraInfo.dialType = static_cast<DialType>(size % DIAL_TYPE);
275     paraInfo.callType = static_cast<CallType>(size % CALL_TYPE_NUM);
276     paraInfo.videoState = static_cast<VideoStateType>(size % VIDIO_TYPE_NUM);
277     paraInfo.callState = static_cast<TelCallState>(size % TEL_CALL_STATE_NUM);
278     sptr<IMSCall> callObjectPtr = std::make_unique<IMSCall>(paraInfo).release();
279     std::string msg(reinterpret_cast<const char *>(data), size);
280     int32_t callingUid = static_cast<int32_t>(size);
281     int32_t callingPid = static_cast<int32_t>(size);
282     int32_t rotation = static_cast<int32_t>(size);
283     ImsCallMode mode = static_cast<ImsCallMode>(size % IMS_CALL_MODE_NUM);
284     CallModeReportInfo callModeReportInfo;
285     callModeReportInfo.callIndex = static_cast<int32_t>(size % CALL_INDEX_MAX_NUM);
286     callModeReportInfo.callMode = static_cast<ImsCallMode>(size % IMS_CALL_MODE_NUM);
287     callModeReportInfo.result = static_cast<VideoRequestResultType>(size % VIDEO_REQUEST_RESULT_TYPE_NUM);
288     callObjectPtr->UpdateImsCallMode(mode);
289     callObjectPtr->SendUpdateCallMediaModeRequest(mode);
290     callObjectPtr->RecieveUpdateCallMediaModeRequest(callModeReportInfo);
291     callObjectPtr->SendUpdateCallMediaModeResponse(mode);
292     callObjectPtr->ReceiveUpdateCallMediaModeResponse(callModeReportInfo);
293     CallMediaModeInfo callMediaModeInfo;
294     callMediaModeInfo.callId = static_cast<int32_t>(size);
295     callMediaModeInfo.isRequestInfo = static_cast<bool>(size % BOOL_NUM);
296     callMediaModeInfo.result = static_cast<VideoRequestResultType>(size % VIDEO_REQUEST_RESULT_TYPE_NUM);
297     callMediaModeInfo.callMode = static_cast<ImsCallMode>(size % IMS_CALL_MODE_NUM);
298     callObjectPtr->ReportImsCallModeInfo(callMediaModeInfo);
299     callObjectPtr->SwitchVideoState(mode);
300     callObjectPtr->IsSupportVideoCall();
301     callObjectPtr->GetCallVideoState(mode);
302     callObjectPtr->ControlCamera(msg, callingUid, callingPid);
303     callObjectPtr->SetPausePicture(msg);
304     callObjectPtr->SetDeviceDirection(rotation);
305     callObjectPtr->CancelCallUpgrade();
306     callObjectPtr->RequestCameraCapabilities();
307 }
308 
IMSVideoCallWindowFunc(const uint8_t * data,size_t size)309 void IMSVideoCallWindowFunc(const uint8_t *data, size_t size)
310 {
311     if (!IsServiceInited()) {
312         return;
313     }
314 
315     DialParaInfo paraInfo;
316     paraInfo.dialType = static_cast<DialType>(size % DIAL_TYPE);
317     paraInfo.callType = static_cast<CallType>(size % CALL_TYPE_NUM);
318     paraInfo.videoState = static_cast<VideoStateType>(size % VIDIO_TYPE_NUM);
319     paraInfo.callState = static_cast<TelCallState>(size % TEL_CALL_STATE_NUM);
320     sptr<IMSCall> callObjectPtr = std::make_unique<IMSCall>(paraInfo).release();
321     std::string msg(reinterpret_cast<const char *>(data), size);
322     int len = static_cast<int>(msg.length());
323     std::string subSurfaceId = msg;
324     if (len >= 1) {
325         subSurfaceId = msg.substr(0, 1);
326     }
327     if (subSurfaceId.empty() || subSurfaceId[0] < '0' || subSurfaceId[0] > '9') {
328         subSurfaceId = "";
329         callObjectPtr->SetPreviewWindow(subSurfaceId, nullptr);
330         callObjectPtr->SetDisplayWindow(subSurfaceId, nullptr);
331     } else {
332         uint64_t tmpSurfaceId = std::stoull(subSurfaceId);
333         auto surface = SurfaceUtils::GetInstance()->GetSurface(tmpSurfaceId);
334         callObjectPtr->SetPreviewWindow(subSurfaceId, surface);
335         callObjectPtr->SetDisplayWindow(subSurfaceId, surface);
336     }
337 }
338 
OttCallFunc(const uint8_t * data,size_t size)339 void OttCallFunc(const uint8_t *data, size_t size)
340 {
341     if (!IsServiceInited()) {
342         return;
343     }
344 
345     DialParaInfo paraInfo;
346     paraInfo.dialType = static_cast<DialType>(size % DIAL_TYPE);
347     paraInfo.callType = static_cast<CallType>(size % CALL_TYPE_NUM);
348     paraInfo.videoState = static_cast<VideoStateType>(size % VIDIO_TYPE_NUM);
349     paraInfo.callState = static_cast<TelCallState>(size % TEL_CALL_STATE_NUM);
350     sptr<OTTCall> callObjectPtr = std::make_unique<OTTCall>(paraInfo).release();
351     int32_t videoState = static_cast<int32_t>(size % VIDIO_TYPE_NUM);
352     int32_t mute = static_cast<int32_t>(size % BOOL_NUM);
353     int32_t slotId = static_cast<int32_t>(size % SLOT_NUM);
354 
355     callObjectPtr->DialingProcess();
356     callObjectPtr->AnswerCall(videoState);
357     callObjectPtr->RejectCall();
358     callObjectPtr->HangUpCall();
359     callObjectPtr->HoldCall();
360     callObjectPtr->UnHoldCall();
361     callObjectPtr->SwitchCall();
362     callObjectPtr->GetEmergencyState();
363     callObjectPtr->StopDtmf();
364     callObjectPtr->GetSlotId();
365     callObjectPtr->CombineConference();
366     callObjectPtr->SeparateConference();
367     callObjectPtr->KickOutFromConference();
368     callObjectPtr->CanCombineConference();
369     callObjectPtr->CanSeparateConference();
370     callObjectPtr->CanKickOutFromConference();
371     callObjectPtr->LaunchConference();
372     callObjectPtr->ExitConference();
373     callObjectPtr->HoldConference();
374     int32_t mainCallId = INVALID_CALL_ID;
375     callObjectPtr->GetMainCallId(mainCallId);
376     std::vector<std::u16string> subCallIdList;
377     callObjectPtr->GetSubCallIdList(subCallIdList);
378     std::vector<std::u16string> callIdList;
379     callObjectPtr->GetCallIdListForConference(callIdList);
380     callObjectPtr->IsSupportConferenceable();
381     callObjectPtr->SetMute(mute, slotId);
382 }
383 
OttVideoCallFunc(const uint8_t * data,size_t size)384 void OttVideoCallFunc(const uint8_t *data, size_t size)
385 {
386     if (!IsServiceInited()) {
387         return;
388     }
389     DialParaInfo paraInfo;
390     paraInfo.dialType = static_cast<DialType>(size % DIAL_TYPE);
391     paraInfo.callType = static_cast<CallType>(size % CALL_TYPE_NUM);
392     paraInfo.videoState = static_cast<VideoStateType>(size % VIDIO_TYPE_NUM);
393     paraInfo.callState = static_cast<TelCallState>(size % TEL_CALL_STATE_NUM);
394     sptr<OTTCall> callObjectPtr = std::make_unique<OTTCall>(paraInfo).release();
395     std::string msg(reinterpret_cast<const char *>(data), size);
396     int32_t callingUid = static_cast<int32_t>(size);
397     int32_t callingPid = static_cast<int32_t>(size);
398     int32_t rotation = static_cast<int32_t>(size);
399     callObjectPtr->InitVideoCall();
400     ImsCallMode mode = static_cast<ImsCallMode>(size % IMS_CALL_MODE_NUM);
401     CallModeReportInfo callModeReportInfo;
402     callModeReportInfo.callIndex = static_cast<int32_t>(size % CALL_INDEX_MAX_NUM);
403     callModeReportInfo.callMode = static_cast<ImsCallMode>(size % IMS_CALL_MODE_NUM);
404     callModeReportInfo.result = static_cast<VideoRequestResultType>(size % VIDEO_REQUEST_RESULT_TYPE_NUM);
405     callObjectPtr->UpdateImsCallMode(mode);
406     callObjectPtr->SendUpdateCallMediaModeRequest(mode);
407     callObjectPtr->RecieveUpdateCallMediaModeRequest(callModeReportInfo);
408     callObjectPtr->SendUpdateCallMediaModeResponse(mode);
409     callObjectPtr->ReceiveUpdateCallMediaModeResponse(callModeReportInfo);
410     CallMediaModeInfo callMediaModeInfo;
411     callMediaModeInfo.callId = static_cast<int32_t>(size);
412     callMediaModeInfo.isRequestInfo = static_cast<bool>(size % BOOL_NUM);
413     callMediaModeInfo.result = static_cast<VideoRequestResultType>(size % VIDEO_REQUEST_RESULT_TYPE_NUM);
414     callMediaModeInfo.callMode = static_cast<ImsCallMode>(size % IMS_CALL_MODE_NUM);
415     callObjectPtr->ReportImsCallModeInfo(callMediaModeInfo);
416     callObjectPtr->ControlCamera(msg, callingUid, callingPid);
417     callObjectPtr->SetPausePicture(msg);
418     callObjectPtr->SetDeviceDirection(rotation);
419     callObjectPtr->CancelCallUpgrade();
420     callObjectPtr->RequestCameraCapabilities();
421 }
422 
OttVideoCallWindowFunc(const uint8_t * data,size_t size)423 void OttVideoCallWindowFunc(const uint8_t *data, size_t size)
424 {
425     if (!IsServiceInited()) {
426         return;
427     }
428     DialParaInfo paraInfo;
429     paraInfo.dialType = static_cast<DialType>(size % DIAL_TYPE);
430     paraInfo.callType = static_cast<CallType>(size % CALL_TYPE_NUM);
431     paraInfo.videoState = static_cast<VideoStateType>(size % VIDIO_TYPE_NUM);
432     paraInfo.callState = static_cast<TelCallState>(size % TEL_CALL_STATE_NUM);
433     sptr<OTTCall> callObjectPtr = std::make_unique<OTTCall>(paraInfo).release();
434     std::string msg(reinterpret_cast<const char *>(data), size);
435     int len = static_cast<int>(msg.length());
436     std::string subSurfaceId = msg;
437     if (len >= 1) {
438         subSurfaceId = msg.substr(0, 1);
439     }
440     if (subSurfaceId.empty() || subSurfaceId[0] < '0' || subSurfaceId[0] > '9') {
441         subSurfaceId = "";
442         callObjectPtr->SetPreviewWindow(subSurfaceId, nullptr);
443         callObjectPtr->SetDisplayWindow(subSurfaceId, nullptr);
444     } else {
445         uint64_t tmpSurfaceId = std::stoull(subSurfaceId);
446         auto surface = SurfaceUtils::GetInstance()->GetSurface(tmpSurfaceId);
447         callObjectPtr->SetPreviewWindow(subSurfaceId, surface);
448         callObjectPtr->SetDisplayWindow(subSurfaceId, surface);
449     }
450 }
451 
SatelliteCallFunc(const uint8_t * data,size_t size)452 void SatelliteCallFunc(const uint8_t *data, size_t size)
453 {
454     if (!IsServiceInited()) {
455         return;
456     }
457 
458     DialParaInfo paraInfo;
459     paraInfo.dialType = static_cast<DialType>(size % DIAL_TYPE);
460     paraInfo.callType = static_cast<CallType>(size % CALL_TYPE_NUM);
461     paraInfo.videoState = static_cast<VideoStateType>(size % VIDIO_TYPE_NUM);
462     paraInfo.callState = static_cast<TelCallState>(size % TEL_CALL_STATE_NUM);
463     sptr<SatelliteCall> callObjectPtr = std::make_unique<SatelliteCall>(paraInfo).release();
464     int32_t videoState = static_cast<int32_t>(size % VIDIO_TYPE_NUM);
465     CallAttributeInfo info;
466 
467     callObjectPtr->DialingProcess();
468     callObjectPtr->AnswerCall(videoState);
469     callObjectPtr->RejectCall();
470     callObjectPtr->HangUpCall();
471     callObjectPtr->GetCallAttributeInfo(info);
472 }
473 
DoSomethingInterestingWithMyAPI(const uint8_t * data,size_t size)474 void DoSomethingInterestingWithMyAPI(const uint8_t *data, size_t size)
475 {
476     if (data == nullptr || size == 0) {
477         return;
478     }
479 
480     CSCallFunc(data, size);
481     DialingProcess(data, size);
482     GetCallerInfo(data, size);
483     IMSCallFunc(data, size);
484     IMSVideoCallFunc(data, size);
485     IMSVideoCallWindowFunc(data, size);
486     OttCallFunc(data, size);
487     VoIPCallFunc(data, size);
488     OttVideoCallFunc(data, size);
489     OttVideoCallWindowFunc(data, size);
490     SatelliteCallFunc(data, size);
491 }
492 } // namespace OHOS
493 
494 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)495 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
496 {
497     OHOS::AddCallTokenFuzzer token;
498     /* Run your code on data */
499     OHOS::DoSomethingInterestingWithMyAPI(data, size);
500     return 0;
501 }
502