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.WriteInt32(slotId);
149 messageParcel.RewindRead(0);
150 MessageParcel reply;
151 return CallStatusCallbackPtr_->OnUpdateCallsReportInfo(messageParcel, reply);
152 }
153
UpdateEventReport(const uint8_t * data,size_t size)154 int32_t UpdateEventReport(const uint8_t *data, size_t size)
155 {
156 if (!ServiceInited()) {
157 return TELEPHONY_ERROR;
158 }
159 MessageParcel messageParcel;
160 if (!messageParcel.WriteInterfaceToken(CallStatusCallbackProxy::GetDescriptor())) {
161 return TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
162 }
163 CellularCallEventInfo info;
164 int32_t length = sizeof(CellularCallEventInfo);
165 info.eventType = CellularCallEventType::EVENT_REQUEST_RESULT_TYPE;
166 info.eventId = RequestResultEventId::INVALID_REQUEST_RESULT_EVENT_ID;
167 messageParcel.WriteInt32(length);
168 messageParcel.WriteRawData((const void *)&info, length);
169 messageParcel.WriteBuffer(data, size);
170 messageParcel.RewindRead(0);
171 MessageParcel reply;
172 return CallStatusCallbackPtr_->OnUpdateEventReport(messageParcel, reply);
173 }
174
UpdateGetWaitingResult(const uint8_t * data,size_t size)175 int32_t UpdateGetWaitingResult(const uint8_t *data, size_t size)
176 {
177 if (!ServiceInited()) {
178 return TELEPHONY_ERROR;
179 }
180 MessageParcel messageParcel;
181 if (!messageParcel.WriteInterfaceToken(CallStatusCallbackProxy::GetDescriptor())) {
182 return TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
183 }
184 CallWaitResponse callWaitResponse;
185 int32_t length = sizeof(CallWaitResponse);
186 messageParcel.WriteInt32(length);
187 callWaitResponse.result = static_cast<int32_t>(*data);
188 callWaitResponse.status = static_cast<int32_t>(*data);
189 callWaitResponse.classCw = static_cast<int32_t>(*data);
190 messageParcel.WriteRawData((const void *)&callWaitResponse, length);
191 messageParcel.RewindRead(0);
192 MessageParcel reply;
193 return CallStatusCallbackPtr_->OnUpdateGetWaitingResult(messageParcel, reply);
194 }
195
UpdateGetRestrictionResult(const uint8_t * data,size_t size)196 int32_t UpdateGetRestrictionResult(const uint8_t *data, size_t size)
197 {
198 if (!ServiceInited()) {
199 return TELEPHONY_ERROR;
200 }
201 MessageParcel messageParcel;
202 if (!messageParcel.WriteInterfaceToken(CallStatusCallbackProxy::GetDescriptor())) {
203 return TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
204 }
205 CallRestrictionResponse callRestrictionResult;
206 int32_t length = sizeof(CallRestrictionResponse);
207 messageParcel.WriteInt32(length);
208 callRestrictionResult.result = static_cast<int32_t>(*data);
209 callRestrictionResult.status = static_cast<int32_t>(*data);
210 callRestrictionResult.classCw = static_cast<int32_t>(*data);
211 messageParcel.WriteRawData((const void *)&callRestrictionResult, length);
212 messageParcel.RewindRead(0);
213 MessageParcel reply;
214 return CallStatusCallbackPtr_->OnUpdateGetRestrictionResult(messageParcel, reply);
215 }
216
UpdateGetTransferResult(const uint8_t * data,size_t size)217 int32_t UpdateGetTransferResult(const uint8_t *data, size_t size)
218 {
219 if (!ServiceInited()) {
220 return TELEPHONY_ERROR;
221 }
222 MessageParcel messageParcel;
223 if (!messageParcel.WriteInterfaceToken(CallStatusCallbackProxy::GetDescriptor())) {
224 return TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
225 }
226 CallTransferResponse callTransferResponse;
227 int32_t length = sizeof(CallTransferResponse);
228 messageParcel.WriteInt32(length);
229 callTransferResponse.result = static_cast<int32_t>(size);
230 callTransferResponse.status = static_cast<int32_t>(size);
231 callTransferResponse.classx = static_cast<int32_t>(size);
232 callTransferResponse.type = static_cast<int32_t>(size);
233 std::string msg(reinterpret_cast<const char *>(data), size);
234 int32_t accountLength = msg.length() > kMaxNumberLen ? kMaxNumberLen : msg.length();
235 memcpy_s(callTransferResponse.number, kMaxNumberLen, msg.c_str(), accountLength);
236 callTransferResponse.reason = static_cast<int32_t>(size);
237 callTransferResponse.time = static_cast<int32_t>(size);
238 callTransferResponse.startHour = static_cast<int32_t>(size);
239 callTransferResponse.startMinute = static_cast<int32_t>(size);
240 callTransferResponse.endHour = static_cast<int32_t>(size);
241 callTransferResponse.endMinute = static_cast<int32_t>(size);
242 messageParcel.WriteRawData((const void *)&callTransferResponse, length);
243 messageParcel.RewindRead(0);
244 MessageParcel reply;
245 return CallStatusCallbackPtr_->OnUpdateGetTransferResult(messageParcel, reply);
246 }
247
UpdateGetCallClipResult(const uint8_t * data,size_t size)248 int32_t UpdateGetCallClipResult(const uint8_t *data, size_t size)
249 {
250 if (!ServiceInited()) {
251 return TELEPHONY_ERROR;
252 }
253 MessageParcel messageParcel;
254 if (!messageParcel.WriteInterfaceToken(CallStatusCallbackProxy::GetDescriptor())) {
255 return TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
256 }
257 ClipResponse clipResponse;
258 int32_t length = sizeof(ClipResponse);
259 messageParcel.WriteInt32(length);
260 clipResponse.result = static_cast<int32_t>(*data);
261 clipResponse.action = static_cast<int32_t>(*data);
262 clipResponse.clipStat = static_cast<int32_t>(*data);
263 messageParcel.WriteRawData((const void *)&clipResponse, length);
264 messageParcel.RewindRead(0);
265 MessageParcel reply;
266 return CallStatusCallbackPtr_->OnUpdateGetCallClipResult(messageParcel, reply);
267 }
268
GetImsConfigResult(const uint8_t * data,size_t size)269 int32_t GetImsConfigResult(const uint8_t *data, size_t size)
270 {
271 if (!ServiceInited()) {
272 return TELEPHONY_ERROR;
273 }
274 MessageParcel messageParcel;
275 if (!messageParcel.WriteInterfaceToken(CallStatusCallbackProxy::GetDescriptor())) {
276 return TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
277 }
278 GetImsConfigResponse response;
279 int32_t length = sizeof(GetImsConfigResponse);
280 messageParcel.WriteInt32(length);
281 response.result = static_cast<int32_t>(*data);
282 response.value = static_cast<int32_t>(*data);
283 messageParcel.WriteRawData((const void *)&response, length);
284 messageParcel.RewindRead(0);
285 MessageParcel reply;
286 return CallStatusCallbackPtr_->OnGetImsConfigResult(messageParcel, reply);
287 }
288
GetImsFeatureValueResult(const uint8_t * data,size_t size)289 int32_t GetImsFeatureValueResult(const uint8_t *data, size_t size)
290 {
291 if (!ServiceInited()) {
292 return TELEPHONY_ERROR;
293 }
294 MessageParcel messageParcel;
295 if (!messageParcel.WriteInterfaceToken(CallStatusCallbackProxy::GetDescriptor())) {
296 return TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
297 }
298 GetImsFeatureValueResponse response;
299 int32_t length = sizeof(GetImsFeatureValueResponse);
300 messageParcel.WriteInt32(length);
301 response.result = static_cast<int32_t>(*data);
302 response.value = static_cast<int32_t>(*data);
303 messageParcel.WriteRawData((const void *)&response, length);
304 messageParcel.RewindRead(0);
305 MessageParcel reply;
306 return CallStatusCallbackPtr_->OnGetImsFeatureValueResult(messageParcel, reply);
307 }
308
SendMmiCodeResult(const uint8_t * data,size_t size)309 int32_t SendMmiCodeResult(const uint8_t *data, size_t size)
310 {
311 if (!ServiceInited()) {
312 return TELEPHONY_ERROR;
313 }
314 MessageParcel messageParcel;
315 if (!messageParcel.WriteInterfaceToken(CallStatusCallbackProxy::GetDescriptor())) {
316 return TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
317 }
318 MmiCodeInfo info;
319 int32_t length = sizeof(MmiCodeInfo);
320 messageParcel.WriteInt32(length);
321 info.result = static_cast<int32_t>(size);
322 std::string msg(reinterpret_cast<const char *>(data), size);
323 int32_t msgLength = msg.length() > kMaxNumberLen ? kMaxNumberLen : msg.length();
324 memcpy_s(info.message, kMaxNumberLen, msg.c_str(), msgLength);
325 messageParcel.WriteRawData((const void *)&info, length);
326 messageParcel.RewindRead(0);
327 MessageParcel reply;
328 return CallStatusCallbackPtr_->OnSendMmiCodeResult(messageParcel, reply);
329 }
330
ReceiveUpdateCallMediaModeRequest(const uint8_t * data,size_t size)331 int32_t ReceiveUpdateCallMediaModeRequest(const uint8_t *data, size_t size)
332 {
333 if (!ServiceInited()) {
334 return TELEPHONY_ERROR;
335 }
336 MessageParcel messageParcel;
337 if (!messageParcel.WriteInterfaceToken(CallStatusCallbackProxy::GetDescriptor())) {
338 return TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
339 }
340
341 int32_t length = sizeof(CallModeReportInfo);
342 messageParcel.WriteInt32(length);
343 CallModeReportInfo callModeReportInfo;
344 callModeReportInfo.callIndex = static_cast<int32_t>(*data % CALL_INDEX_MAX_NUM);
345 callModeReportInfo.callMode = static_cast<ImsCallMode>(*data % IMS_CALL_MODE_NUM);
346 callModeReportInfo.result = static_cast<VideoRequestResultType>(*data % VIDEO_REQUEST_RESULT_TYPE_NUM);
347 messageParcel.WriteRawData((const void *)&callModeReportInfo, length);
348 messageParcel.RewindRead(0);
349 MessageParcel reply;
350 return CallStatusCallbackPtr_->OnReceiveImsCallModeRequest(messageParcel, reply);
351 }
352
ReceiveUpdateCallMediaModeResponse(const uint8_t * data,size_t size)353 int32_t ReceiveUpdateCallMediaModeResponse(const uint8_t *data, size_t size)
354 {
355 if (!ServiceInited()) {
356 return TELEPHONY_ERROR;
357 }
358 MessageParcel messageParcel;
359 if (!messageParcel.WriteInterfaceToken(CallStatusCallbackProxy::GetDescriptor())) {
360 return TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
361 }
362
363 int32_t length = sizeof(CallModeReportInfo);
364 messageParcel.WriteInt32(length);
365 CallModeReportInfo callModeReportInfo;
366 callModeReportInfo.callIndex = static_cast<int32_t>(*data % CALL_INDEX_MAX_NUM);
367 callModeReportInfo.callMode = static_cast<ImsCallMode>(*data % IMS_CALL_MODE_NUM);
368 callModeReportInfo.result = static_cast<VideoRequestResultType>(*data % VIDEO_REQUEST_RESULT_TYPE_NUM);
369 messageParcel.WriteRawData((const void *)&callModeReportInfo, length);
370 messageParcel.RewindRead(0);
371 MessageParcel reply;
372 return CallStatusCallbackPtr_->OnReceiveImsCallModeResponse(messageParcel, reply);
373 }
374
HandleCallSessionEventChanged(const uint8_t * data,size_t size)375 int32_t HandleCallSessionEventChanged(const uint8_t *data, size_t size)
376 {
377 if (!ServiceInited()) {
378 return TELEPHONY_ERROR;
379 }
380 MessageParcel messageParcel;
381 if (!messageParcel.WriteInterfaceToken(CallStatusCallbackProxy::GetDescriptor())) {
382 return TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
383 }
384
385 int32_t length = sizeof(CallSessionReportInfo);
386 messageParcel.WriteInt32(length);
387 CallSessionReportInfo callSessionReportInfo;
388 callSessionReportInfo.index = static_cast<int32_t>(*data % CALL_INDEX_MAX_NUM);
389 callSessionReportInfo.eventId = static_cast<CallSessionEventId>(*data % CALL_SESSION_EVENT_ID_NUM);
390 messageParcel.WriteRawData((const void *)&callSessionReportInfo, length);
391 messageParcel.RewindRead(0);
392 MessageParcel reply;
393 return CallStatusCallbackPtr_->OnCallSessionEventChange(messageParcel, reply);
394 }
395
HandlePeerDimensionsChanged(const uint8_t * data,size_t size)396 int32_t HandlePeerDimensionsChanged(const uint8_t *data, size_t size)
397 {
398 if (!ServiceInited()) {
399 return TELEPHONY_ERROR;
400 }
401 MessageParcel messageParcel;
402 if (!messageParcel.WriteInterfaceToken(CallStatusCallbackProxy::GetDescriptor())) {
403 return TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
404 }
405
406 int32_t length = sizeof(PeerDimensionsReportInfo);
407 messageParcel.WriteInt32(length);
408 PeerDimensionsReportInfo dimensionsReportInfo;
409 dimensionsReportInfo.index = static_cast<int32_t>(*data % CALL_INDEX_MAX_NUM);
410 dimensionsReportInfo.width = static_cast<int32_t>(*data);
411 dimensionsReportInfo.height = static_cast<int32_t>(*data);
412 messageParcel.WriteRawData((const void *)&dimensionsReportInfo, length);
413 messageParcel.RewindRead(0);
414 MessageParcel reply;
415 return CallStatusCallbackPtr_->OnPeerDimensionsChange(messageParcel, reply);
416 }
417
HandleCallDataUsageChanged(const uint8_t * data,size_t size)418 int32_t HandleCallDataUsageChanged(const uint8_t *data, size_t size)
419 {
420 if (!ServiceInited()) {
421 return TELEPHONY_ERROR;
422 }
423 MessageParcel messageParcel;
424 if (!messageParcel.WriteInterfaceToken(CallStatusCallbackProxy::GetDescriptor())) {
425 return TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
426 }
427
428 int64_t reportInfo = static_cast<int64_t>(*data);
429 messageParcel.WriteInt64(reportInfo);
430 messageParcel.RewindRead(0);
431 MessageParcel reply;
432 return CallStatusCallbackPtr_->OnCallDataUsageChange(messageParcel, reply);
433 }
434
HandleCameraCapabilitiesChanged(const uint8_t * data,size_t size)435 int32_t HandleCameraCapabilitiesChanged(const uint8_t *data, size_t size)
436 {
437 if (!ServiceInited()) {
438 return TELEPHONY_ERROR;
439 }
440 MessageParcel messageParcel;
441 if (!messageParcel.WriteInterfaceToken(CallStatusCallbackProxy::GetDescriptor())) {
442 return TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
443 }
444
445 int32_t length = sizeof(CameraCapabilitiesReportInfo);
446 messageParcel.WriteInt32(length);
447 CameraCapabilitiesReportInfo cameraCapabilitiesReportInfo;
448 cameraCapabilitiesReportInfo.index = static_cast<int32_t>(*data % CALL_INDEX_MAX_NUM);
449 cameraCapabilitiesReportInfo.width = static_cast<int32_t>(*data);
450 cameraCapabilitiesReportInfo.height = static_cast<int32_t>(*data);
451 messageParcel.WriteRawData((const void *)&cameraCapabilitiesReportInfo, length);
452 messageParcel.RewindRead(0);
453 MessageParcel reply;
454 return CallStatusCallbackPtr_->OnCameraCapabilitiesChange(messageParcel, reply);
455 }
456
DoSomethingInterestingWithMyAPI(const uint8_t * data,size_t size)457 void DoSomethingInterestingWithMyAPI(const uint8_t *data, size_t size)
458 {
459 if (data == nullptr || size == 0) {
460 return;
461 }
462 OnRemoteRequest(data, size);
463 UpdateCallReportInfo(data, size);
464 UpdateCallsReportInfo(data, size);
465 UpdateEventReport(data, size);
466 UpdateGetWaitingResult(data, size);
467 UpdateGetRestrictionResult(data, size);
468 UpdateGetTransferResult(data, size);
469 UpdateGetCallClipResult(data, size);
470 GetImsConfigResult(data, size);
471 GetImsFeatureValueResult(data, size);
472 SendMmiCodeResult(data, size);
473 ReceiveUpdateCallMediaModeRequest(data, size);
474 ReceiveUpdateCallMediaModeResponse(data, size);
475 HandleCallSessionEventChanged(data, size);
476 HandlePeerDimensionsChanged(data, size);
477 HandleCallDataUsageChanged(data, size);
478 HandleCameraCapabilitiesChanged(data, size);
479 }
480 } // namespace OHOS
481
482 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)483 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
484 {
485 OHOS::AddCallTokenFuzzer token;
486 /* Run your code on data */
487 OHOS::DoSomethingInterestingWithMyAPI(data, size);
488 return 0;
489 }
490