1 /*
2 * Copyright (c) 2023 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 "telephonyinteraction_fuzzer.h"
17
18 #include <cstddef>
19 #include <cstdint>
20 #define private public
21 #include "addcalltoken_fuzzer.h"
22 #include "call_status_callback_proxy.h"
23
24 using namespace OHOS::Telephony;
25 namespace OHOS {
26 constexpr int32_t SLOT_NUM = 2;
27 constexpr int32_t ACCOUNT_ID_NUM = 10;
28 constexpr int32_t MULTI_PARTY_NUM = 10;
29 constexpr int32_t VOICE_DOMAIN_NUM = 10;
30 constexpr int32_t IMS_CALL_MODE_NUM = 5;
31 constexpr int32_t CALL_INDEX_MAX_NUM = 8;
32 constexpr int32_t VIDEO_REQUEST_RESULT_TYPE_NUM = 102;
33 constexpr int32_t CALL_SESSION_EVENT_ID_NUM = 4;
34 std::unique_ptr<CallStatusCallback> CallStatusCallbackPtr_ = nullptr;
35
ServiceInited()36 bool ServiceInited()
37 {
38 bool result = true;
39 if (!IsServiceInited()) {
40 return false;
41 }
42 CallStatusCallbackPtr_ = std::make_unique<CallStatusCallback>();
43 if (CallStatusCallbackPtr_ == nullptr) {
44 result = false;
45 }
46 return result;
47 }
48
OnRemoteRequest(const uint8_t * data,size_t size)49 int32_t OnRemoteRequest(const uint8_t *data, size_t size)
50 {
51 if (!ServiceInited()) {
52 return TELEPHONY_ERROR;
53 }
54 MessageParcel messageParcel;
55 if (!messageParcel.WriteInterfaceToken(CallStatusCallbackStub::GetDescriptor())) {
56 return TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
57 }
58 messageParcel.RewindRead(0);
59 uint32_t code = static_cast<uint32_t>(*data);
60 MessageParcel reply;
61 MessageOption option;
62 return CallStatusCallbackPtr_->OnRemoteRequest(code, messageParcel, reply, option);
63 }
64
UpdateCallReportInfo(const uint8_t * data,size_t size)65 int32_t UpdateCallReportInfo(const uint8_t *data, size_t size)
66 {
67 if (!ServiceInited()) {
68 return TELEPHONY_ERROR;
69 }
70 MessageParcel messageParcel;
71 if (!messageParcel.WriteInterfaceToken(CallStatusCallbackProxy::GetDescriptor())) {
72 return TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
73 }
74 CallReportInfo callReportInfo;
75 callReportInfo.index = static_cast<int32_t>(size);
76 callReportInfo.accountId = static_cast<int32_t>(size % ACCOUNT_ID_NUM);
77 callReportInfo.voiceDomain = static_cast<int32_t>(size % VOICE_DOMAIN_NUM);
78 callReportInfo.mpty = static_cast<int32_t>(size % MULTI_PARTY_NUM);
79 callReportInfo.callType = CallType::TYPE_ERR_CALL;
80 callReportInfo.callMode = VideoStateType::TYPE_VOICE;
81 callReportInfo.state = TelCallState::CALL_STATUS_UNKNOWN;
82 std::string msg(reinterpret_cast<const char *>(data), size);
83 int32_t accountLength = msg.length() > kMaxNumberLen ? kMaxNumberLen : msg.length();
84 memcpy_s(callReportInfo.accountNum, kMaxNumberLen, msg.c_str(), accountLength);
85 messageParcel.WriteInt32(callReportInfo.index);
86 messageParcel.WriteCString(callReportInfo.accountNum);
87 messageParcel.WriteInt32(callReportInfo.accountId);
88 messageParcel.WriteInt32(static_cast<int32_t>(callReportInfo.callType));
89 messageParcel.WriteInt32(static_cast<int32_t>(callReportInfo.callMode));
90 messageParcel.WriteInt32(static_cast<int32_t>(callReportInfo.state));
91 messageParcel.WriteInt32(callReportInfo.voiceDomain);
92 messageParcel.WriteInt32(callReportInfo.mpty);
93 messageParcel.WriteInt32(callReportInfo.crsType);
94 messageParcel.WriteInt32(callReportInfo.originalCallType);
95 messageParcel.WriteString(callReportInfo.voipCallInfo.voipCallId);
96 messageParcel.WriteString(callReportInfo.voipCallInfo.userName);
97 messageParcel.WriteString(callReportInfo.voipCallInfo.abilityName);
98 messageParcel.WriteString(callReportInfo.voipCallInfo.extensionId);
99 messageParcel.WriteString(callReportInfo.voipCallInfo.voipBundleName);
100 messageParcel.WriteUInt8Vector(callReportInfo.voipCallInfo.userProfile);
101 messageParcel.RewindRead(0);
102 MessageParcel reply;
103 return CallStatusCallbackPtr_->OnUpdateCallReportInfo(messageParcel, reply);
104 }
105
UpdateCallsReportInfo(const uint8_t * data,size_t size)106 int32_t UpdateCallsReportInfo(const uint8_t *data, size_t size)
107 {
108 if (!ServiceInited()) {
109 return TELEPHONY_ERROR;
110 }
111 MessageParcel messageParcel;
112 if (!messageParcel.WriteInterfaceToken(CallStatusCallbackProxy::GetDescriptor())) {
113 return TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
114 }
115 CallReportInfo info;
116 int32_t slotId = static_cast<int32_t>(size % SLOT_NUM);
117 int32_t vecSize = 1;
118 info.index = static_cast<int32_t>(size);
119 info.accountId = static_cast<int32_t>(size % ACCOUNT_ID_NUM);
120 info.voiceDomain = static_cast<int32_t>(size % VOICE_DOMAIN_NUM);
121 info.mpty = static_cast<int32_t>(size % MULTI_PARTY_NUM);
122 info.callType = CallType::TYPE_ERR_CALL;
123 info.callMode = VideoStateType::TYPE_VOICE;
124 info.state = TelCallState::CALL_STATUS_UNKNOWN;
125 std::string msg(reinterpret_cast<const char *>(data), size);
126 int32_t accountLength = msg.length() > kMaxNumberLen ? kMaxNumberLen : msg.length();
127 memcpy_s(info.accountNum, kMaxNumberLen, msg.c_str(), accountLength);
128 messageParcel.WriteInt32(vecSize);
129 messageParcel.WriteInt32(info.index);
130 messageParcel.WriteCString(info.accountNum);
131 messageParcel.WriteInt32(info.accountId);
132 messageParcel.WriteInt32(static_cast<int32_t>(info.callType));
133 messageParcel.WriteInt32(static_cast<int32_t>(info.callMode));
134 messageParcel.WriteInt32(static_cast<int32_t>(info.state));
135 messageParcel.WriteInt32(info.voiceDomain);
136 messageParcel.WriteInt32(info.mpty);
137 messageParcel.WriteInt32(info.crsType);
138 messageParcel.WriteInt32(info.originalCallType);
139 messageParcel.WriteString(info.voipCallInfo.voipCallId);
140 messageParcel.WriteString(info.voipCallInfo.userName);
141 messageParcel.WriteString(info.voipCallInfo.abilityName);
142 messageParcel.WriteString(info.voipCallInfo.extensionId);
143 messageParcel.WriteString(info.voipCallInfo.voipBundleName);
144 messageParcel.WriteUInt8Vector(info.voipCallInfo.userProfile);
145 messageParcel.WriteString(info.name);
146 messageParcel.WriteInt32(info.namePresentation);
147 messageParcel.WriteInt32(static_cast<int32_t>(info.reason));
148 messageParcel.WriteString(info.message);
149 messageParcel.WriteInt32(slotId);
150 messageParcel.RewindRead(0);
151 MessageParcel reply;
152 return CallStatusCallbackPtr_->OnUpdateCallsReportInfo(messageParcel, reply);
153 }
154
UpdateEventReport(const uint8_t * data,size_t size)155 int32_t UpdateEventReport(const uint8_t *data, size_t size)
156 {
157 if (!ServiceInited()) {
158 return TELEPHONY_ERROR;
159 }
160 MessageParcel messageParcel;
161 if (!messageParcel.WriteInterfaceToken(CallStatusCallbackProxy::GetDescriptor())) {
162 return TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
163 }
164 CellularCallEventInfo info;
165 int32_t length = sizeof(CellularCallEventInfo);
166 info.eventType = CellularCallEventType::EVENT_REQUEST_RESULT_TYPE;
167 info.eventId = RequestResultEventId::INVALID_REQUEST_RESULT_EVENT_ID;
168 messageParcel.WriteInt32(length);
169 messageParcel.WriteRawData((const void *)&info, length);
170 messageParcel.WriteBuffer(data, size);
171 messageParcel.RewindRead(0);
172 MessageParcel reply;
173 return CallStatusCallbackPtr_->OnUpdateEventReport(messageParcel, reply);
174 }
175
UpdateGetWaitingResult(const uint8_t * data,size_t size)176 int32_t UpdateGetWaitingResult(const uint8_t *data, size_t size)
177 {
178 if (!ServiceInited()) {
179 return TELEPHONY_ERROR;
180 }
181 MessageParcel messageParcel;
182 if (!messageParcel.WriteInterfaceToken(CallStatusCallbackProxy::GetDescriptor())) {
183 return TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
184 }
185 CallWaitResponse callWaitResponse;
186 int32_t length = sizeof(CallWaitResponse);
187 messageParcel.WriteInt32(length);
188 callWaitResponse.result = static_cast<int32_t>(*data);
189 callWaitResponse.status = static_cast<int32_t>(*data);
190 callWaitResponse.classCw = static_cast<int32_t>(*data);
191 messageParcel.WriteRawData((const void *)&callWaitResponse, length);
192 messageParcel.RewindRead(0);
193 MessageParcel reply;
194 return CallStatusCallbackPtr_->OnUpdateGetWaitingResult(messageParcel, reply);
195 }
196
UpdateGetRestrictionResult(const uint8_t * data,size_t size)197 int32_t UpdateGetRestrictionResult(const uint8_t *data, size_t size)
198 {
199 if (!ServiceInited()) {
200 return TELEPHONY_ERROR;
201 }
202 MessageParcel messageParcel;
203 if (!messageParcel.WriteInterfaceToken(CallStatusCallbackProxy::GetDescriptor())) {
204 return TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
205 }
206 CallRestrictionResponse callRestrictionResult;
207 int32_t length = sizeof(CallRestrictionResponse);
208 messageParcel.WriteInt32(length);
209 callRestrictionResult.result = static_cast<int32_t>(*data);
210 callRestrictionResult.status = static_cast<int32_t>(*data);
211 callRestrictionResult.classCw = static_cast<int32_t>(*data);
212 messageParcel.WriteRawData((const void *)&callRestrictionResult, length);
213 messageParcel.RewindRead(0);
214 MessageParcel reply;
215 return CallStatusCallbackPtr_->OnUpdateGetRestrictionResult(messageParcel, reply);
216 }
217
UpdateGetTransferResult(const uint8_t * data,size_t size)218 int32_t UpdateGetTransferResult(const uint8_t *data, size_t size)
219 {
220 if (!ServiceInited()) {
221 return TELEPHONY_ERROR;
222 }
223 MessageParcel messageParcel;
224 if (!messageParcel.WriteInterfaceToken(CallStatusCallbackProxy::GetDescriptor())) {
225 return TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
226 }
227 CallTransferResponse callTransferResponse;
228 int32_t length = sizeof(CallTransferResponse);
229 messageParcel.WriteInt32(length);
230 callTransferResponse.result = static_cast<int32_t>(size);
231 callTransferResponse.status = static_cast<int32_t>(size);
232 callTransferResponse.classx = static_cast<int32_t>(size);
233 callTransferResponse.type = static_cast<int32_t>(size);
234 std::string msg(reinterpret_cast<const char *>(data), size);
235 int32_t accountLength = msg.length() > kMaxNumberLen ? kMaxNumberLen : msg.length();
236 memcpy_s(callTransferResponse.number, kMaxNumberLen, msg.c_str(), accountLength);
237 callTransferResponse.reason = static_cast<int32_t>(size);
238 callTransferResponse.time = static_cast<int32_t>(size);
239 callTransferResponse.startHour = static_cast<int32_t>(size);
240 callTransferResponse.startMinute = static_cast<int32_t>(size);
241 callTransferResponse.endHour = static_cast<int32_t>(size);
242 callTransferResponse.endMinute = static_cast<int32_t>(size);
243 messageParcel.WriteRawData((const void *)&callTransferResponse, length);
244 messageParcel.RewindRead(0);
245 MessageParcel reply;
246 return CallStatusCallbackPtr_->OnUpdateGetTransferResult(messageParcel, reply);
247 }
248
UpdateGetCallClipResult(const uint8_t * data,size_t size)249 int32_t UpdateGetCallClipResult(const uint8_t *data, size_t size)
250 {
251 if (!ServiceInited()) {
252 return TELEPHONY_ERROR;
253 }
254 MessageParcel messageParcel;
255 if (!messageParcel.WriteInterfaceToken(CallStatusCallbackProxy::GetDescriptor())) {
256 return TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
257 }
258 ClipResponse clipResponse;
259 int32_t length = sizeof(ClipResponse);
260 messageParcel.WriteInt32(length);
261 clipResponse.result = static_cast<int32_t>(*data);
262 clipResponse.action = static_cast<int32_t>(*data);
263 clipResponse.clipStat = static_cast<int32_t>(*data);
264 messageParcel.WriteRawData((const void *)&clipResponse, length);
265 messageParcel.RewindRead(0);
266 MessageParcel reply;
267 return CallStatusCallbackPtr_->OnUpdateGetCallClipResult(messageParcel, reply);
268 }
269
GetImsConfigResult(const uint8_t * data,size_t size)270 int32_t GetImsConfigResult(const uint8_t *data, size_t size)
271 {
272 if (!ServiceInited()) {
273 return TELEPHONY_ERROR;
274 }
275 MessageParcel messageParcel;
276 if (!messageParcel.WriteInterfaceToken(CallStatusCallbackProxy::GetDescriptor())) {
277 return TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
278 }
279 GetImsConfigResponse response;
280 int32_t length = sizeof(GetImsConfigResponse);
281 messageParcel.WriteInt32(length);
282 response.result = static_cast<int32_t>(*data);
283 response.value = static_cast<int32_t>(*data);
284 messageParcel.WriteRawData((const void *)&response, length);
285 messageParcel.RewindRead(0);
286 MessageParcel reply;
287 return CallStatusCallbackPtr_->OnGetImsConfigResult(messageParcel, reply);
288 }
289
GetImsFeatureValueResult(const uint8_t * data,size_t size)290 int32_t GetImsFeatureValueResult(const uint8_t *data, size_t size)
291 {
292 if (!ServiceInited()) {
293 return TELEPHONY_ERROR;
294 }
295 MessageParcel messageParcel;
296 if (!messageParcel.WriteInterfaceToken(CallStatusCallbackProxy::GetDescriptor())) {
297 return TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
298 }
299 GetImsFeatureValueResponse response;
300 int32_t length = sizeof(GetImsFeatureValueResponse);
301 messageParcel.WriteInt32(length);
302 response.result = static_cast<int32_t>(*data);
303 response.value = static_cast<int32_t>(*data);
304 messageParcel.WriteRawData((const void *)&response, length);
305 messageParcel.RewindRead(0);
306 MessageParcel reply;
307 return CallStatusCallbackPtr_->OnGetImsFeatureValueResult(messageParcel, reply);
308 }
309
SendMmiCodeResult(const uint8_t * data,size_t size)310 int32_t SendMmiCodeResult(const uint8_t *data, size_t size)
311 {
312 if (!ServiceInited()) {
313 return TELEPHONY_ERROR;
314 }
315 MessageParcel messageParcel;
316 if (!messageParcel.WriteInterfaceToken(CallStatusCallbackProxy::GetDescriptor())) {
317 return TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
318 }
319 MmiCodeInfo info;
320 int32_t length = sizeof(MmiCodeInfo);
321 messageParcel.WriteInt32(length);
322 info.result = static_cast<int32_t>(size);
323 std::string msg(reinterpret_cast<const char *>(data), size);
324 int32_t msgLength = msg.length() > kMaxNumberLen ? kMaxNumberLen : msg.length();
325 memcpy_s(info.message, kMaxNumberLen, msg.c_str(), msgLength);
326 messageParcel.WriteRawData((const void *)&info, length);
327 messageParcel.RewindRead(0);
328 MessageParcel reply;
329 return CallStatusCallbackPtr_->OnSendMmiCodeResult(messageParcel, reply);
330 }
331
ReceiveUpdateCallMediaModeRequest(const uint8_t * data,size_t size)332 int32_t ReceiveUpdateCallMediaModeRequest(const uint8_t *data, size_t size)
333 {
334 if (!ServiceInited()) {
335 return TELEPHONY_ERROR;
336 }
337 MessageParcel messageParcel;
338 if (!messageParcel.WriteInterfaceToken(CallStatusCallbackProxy::GetDescriptor())) {
339 return TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
340 }
341
342 int32_t length = sizeof(CallModeReportInfo);
343 messageParcel.WriteInt32(length);
344 CallModeReportInfo callModeReportInfo;
345 callModeReportInfo.callIndex = static_cast<int32_t>(*data % CALL_INDEX_MAX_NUM);
346 callModeReportInfo.callMode = static_cast<ImsCallMode>(*data % IMS_CALL_MODE_NUM);
347 callModeReportInfo.result = static_cast<VideoRequestResultType>(*data % VIDEO_REQUEST_RESULT_TYPE_NUM);
348 messageParcel.WriteRawData((const void *)&callModeReportInfo, length);
349 messageParcel.RewindRead(0);
350 MessageParcel reply;
351 return CallStatusCallbackPtr_->OnReceiveImsCallModeRequest(messageParcel, reply);
352 }
353
ReceiveUpdateCallMediaModeResponse(const uint8_t * data,size_t size)354 int32_t ReceiveUpdateCallMediaModeResponse(const uint8_t *data, size_t size)
355 {
356 if (!ServiceInited()) {
357 return TELEPHONY_ERROR;
358 }
359 MessageParcel messageParcel;
360 if (!messageParcel.WriteInterfaceToken(CallStatusCallbackProxy::GetDescriptor())) {
361 return TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
362 }
363
364 int32_t length = sizeof(CallModeReportInfo);
365 messageParcel.WriteInt32(length);
366 CallModeReportInfo callModeReportInfo;
367 callModeReportInfo.callIndex = static_cast<int32_t>(*data % CALL_INDEX_MAX_NUM);
368 callModeReportInfo.callMode = static_cast<ImsCallMode>(*data % IMS_CALL_MODE_NUM);
369 callModeReportInfo.result = static_cast<VideoRequestResultType>(*data % VIDEO_REQUEST_RESULT_TYPE_NUM);
370 messageParcel.WriteRawData((const void *)&callModeReportInfo, length);
371 messageParcel.RewindRead(0);
372 MessageParcel reply;
373 return CallStatusCallbackPtr_->OnReceiveImsCallModeResponse(messageParcel, reply);
374 }
375
HandleCallSessionEventChanged(const uint8_t * data,size_t size)376 int32_t HandleCallSessionEventChanged(const uint8_t *data, size_t size)
377 {
378 if (!ServiceInited()) {
379 return TELEPHONY_ERROR;
380 }
381 MessageParcel messageParcel;
382 if (!messageParcel.WriteInterfaceToken(CallStatusCallbackProxy::GetDescriptor())) {
383 return TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
384 }
385
386 int32_t length = sizeof(CallSessionReportInfo);
387 messageParcel.WriteInt32(length);
388 CallSessionReportInfo callSessionReportInfo;
389 callSessionReportInfo.index = static_cast<int32_t>(*data % CALL_INDEX_MAX_NUM);
390 callSessionReportInfo.eventId = static_cast<CallSessionEventId>(*data % CALL_SESSION_EVENT_ID_NUM);
391 messageParcel.WriteRawData((const void *)&callSessionReportInfo, length);
392 messageParcel.RewindRead(0);
393 MessageParcel reply;
394 return CallStatusCallbackPtr_->OnCallSessionEventChange(messageParcel, reply);
395 }
396
HandlePeerDimensionsChanged(const uint8_t * data,size_t size)397 int32_t HandlePeerDimensionsChanged(const uint8_t *data, size_t size)
398 {
399 if (!ServiceInited()) {
400 return TELEPHONY_ERROR;
401 }
402 MessageParcel messageParcel;
403 if (!messageParcel.WriteInterfaceToken(CallStatusCallbackProxy::GetDescriptor())) {
404 return TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
405 }
406
407 int32_t length = sizeof(PeerDimensionsReportInfo);
408 messageParcel.WriteInt32(length);
409 PeerDimensionsReportInfo dimensionsReportInfo;
410 dimensionsReportInfo.index = static_cast<int32_t>(*data % CALL_INDEX_MAX_NUM);
411 dimensionsReportInfo.width = static_cast<int32_t>(*data);
412 dimensionsReportInfo.height = static_cast<int32_t>(*data);
413 messageParcel.WriteRawData((const void *)&dimensionsReportInfo, length);
414 messageParcel.RewindRead(0);
415 MessageParcel reply;
416 return CallStatusCallbackPtr_->OnPeerDimensionsChange(messageParcel, reply);
417 }
418
HandleCallDataUsageChanged(const uint8_t * data,size_t size)419 int32_t HandleCallDataUsageChanged(const uint8_t *data, size_t size)
420 {
421 if (!ServiceInited()) {
422 return TELEPHONY_ERROR;
423 }
424 MessageParcel messageParcel;
425 if (!messageParcel.WriteInterfaceToken(CallStatusCallbackProxy::GetDescriptor())) {
426 return TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
427 }
428
429 int64_t reportInfo = static_cast<int64_t>(*data);
430 messageParcel.WriteInt64(reportInfo);
431 messageParcel.RewindRead(0);
432 MessageParcel reply;
433 return CallStatusCallbackPtr_->OnCallDataUsageChange(messageParcel, reply);
434 }
435
HandleCameraCapabilitiesChanged(const uint8_t * data,size_t size)436 int32_t HandleCameraCapabilitiesChanged(const uint8_t *data, size_t size)
437 {
438 if (!ServiceInited()) {
439 return TELEPHONY_ERROR;
440 }
441 MessageParcel messageParcel;
442 if (!messageParcel.WriteInterfaceToken(CallStatusCallbackProxy::GetDescriptor())) {
443 return TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
444 }
445
446 int32_t length = sizeof(CameraCapabilitiesReportInfo);
447 messageParcel.WriteInt32(length);
448 CameraCapabilitiesReportInfo cameraCapabilitiesReportInfo;
449 cameraCapabilitiesReportInfo.index = static_cast<int32_t>(*data % CALL_INDEX_MAX_NUM);
450 cameraCapabilitiesReportInfo.width = static_cast<int32_t>(*data);
451 cameraCapabilitiesReportInfo.height = static_cast<int32_t>(*data);
452 messageParcel.WriteRawData((const void *)&cameraCapabilitiesReportInfo, length);
453 messageParcel.RewindRead(0);
454 MessageParcel reply;
455 return CallStatusCallbackPtr_->OnCameraCapabilitiesChange(messageParcel, reply);
456 }
457
DoSomethingInterestingWithMyAPI(const uint8_t * data,size_t size)458 void DoSomethingInterestingWithMyAPI(const uint8_t *data, size_t size)
459 {
460 if (data == nullptr || size == 0) {
461 return;
462 }
463 OnRemoteRequest(data, size);
464 UpdateCallReportInfo(data, size);
465 UpdateCallsReportInfo(data, size);
466 UpdateEventReport(data, size);
467 UpdateGetWaitingResult(data, size);
468 UpdateGetRestrictionResult(data, size);
469 UpdateGetTransferResult(data, size);
470 UpdateGetCallClipResult(data, size);
471 GetImsConfigResult(data, size);
472 GetImsFeatureValueResult(data, size);
473 SendMmiCodeResult(data, size);
474 ReceiveUpdateCallMediaModeRequest(data, size);
475 ReceiveUpdateCallMediaModeResponse(data, size);
476 HandleCallSessionEventChanged(data, size);
477 HandlePeerDimensionsChanged(data, size);
478 HandleCallDataUsageChanged(data, size);
479 HandleCameraCapabilitiesChanged(data, size);
480 }
481 } // namespace OHOS
482
483 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)484 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
485 {
486 OHOS::AddCallTokenFuzzer token;
487 /* Run your code on data */
488 OHOS::DoSomethingInterestingWithMyAPI(data, size);
489 return 0;
490 }
491