1/*
2 * Copyright (c) 2024 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 "distributedschedstub_fuzzer.h"
17
18#include <cstddef>
19#include <cstdint>
20#include <singleton.h>
21
22#include "distributed_sched_interface.h"
23#include "distributed_sched_service.h"
24#include "distributed_sched_stub.h"
25#include "distributedWant/distributed_want.h"
26#include "mock_fuzz_util.h"
27#include "mock_distributed_sched.h"
28#include "parcel_helper.h"
29#include "dms_continue_time_dumper.h"
30
31using namespace OHOS::AAFwk;
32using namespace OHOS::AppExecFwk;
33
34namespace OHOS {
35namespace DistributedSchedule {
36const std::string TAG = "DistributedSchedFuzzTest";
37namespace {
38const std::u16string DMS_STUB_INTERFACE_TOKEN = u"ohos.distributedschedule.accessToken";
39const uint32_t ONE = 1;
40constexpr size_t FOO_MAX_LEN = 1024;
41constexpr size_t U32_AT_SIZE = 4;
42}
43
44uint32_t GetU32Data(const uint8_t* ptr, size_t size)
45{
46    if (size > FOO_MAX_LEN || size < U32_AT_SIZE) {
47        return 0;
48    }
49    char *ch = (char *)malloc(size + 1);
50    if (ch == nullptr) {
51        std::cout << "malloc failed." << std::endl;
52        return 0;
53    }
54    (void)memset_s(ch, size + 1, 0x00, size + 1);
55    if (memcpy_s(ch, size + 1, ptr, size) != EOK) {
56        std::cout << "copy failed." << std::endl;
57        free(ch);
58        ch = nullptr;
59        return 0;
60    }
61    uint32_t data = (ch[0] << 24) | (ch[1] << 16) | (ch[2] << 8) | ch[3];
62    free(ch);
63    ch = nullptr;
64    return data;
65}
66
67bool StartRemoteAbilityInnerFuzzTest(const uint8_t* data, size_t size)
68{
69    if ((data == nullptr) || (size < sizeof(int32_t))) {
70        return false;
71    }
72    MessageParcel dataParcel;
73    MessageParcel reply;
74    Want want;
75    int32_t int32Data = *(reinterpret_cast<const int32_t*>(data));
76    uint32_t uint32Data = *(reinterpret_cast<const uint32_t*>(data));
77
78    PARCEL_WRITE_HELPER(dataParcel, Parcelable, &want);
79    PARCEL_WRITE_HELPER(dataParcel, Int32, int32Data);
80    PARCEL_WRITE_HELPER(dataParcel, Int32, int32Data);
81    PARCEL_WRITE_HELPER(dataParcel, Uint32, uint32Data);
82    DistributedSchedService::GetInstance().StartRemoteAbilityInner(dataParcel, reply);
83    FuzzUtil::MockPermission();
84    DistributedSchedService::GetInstance().StartRemoteAbilityInner(dataParcel, reply);
85    return true;
86}
87
88void ConnectRemoteAbilityInnerFuzzTest(const uint8_t* data, size_t size)
89{
90    if ((data == nullptr) || (size < sizeof(int32_t))) {
91        return;
92    }
93    FuzzUtil::MockPermission();
94    MessageParcel dataParcel;
95    MessageParcel reply;
96    MessageOption option;
97    Want want;
98    sptr<IRemoteObject> connect(new MockDistributedSched());
99    int32_t int32Data = *(reinterpret_cast<const int32_t*>(data));
100    uint32_t uint32Data = *(reinterpret_cast<const uint32_t*>(data));
101
102    PARCEL_WRITE_HELPER_NORET(dataParcel, Parcelable, &want);
103    PARCEL_WRITE_HELPER_NORET(dataParcel, RemoteObject, connect);
104    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
105    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
106    PARCEL_WRITE_HELPER_NORET(dataParcel, Uint32, uint32Data);
107    DistributedSchedService::GetInstance().ConnectRemoteAbilityInner(dataParcel, reply);
108    std::string devId(reinterpret_cast<const char*>(data), size);
109    DistributedSchedService::GetInstance().InitDataShareManager();
110    DistributedSchedService::GetInstance().InitCommonEventListener();
111    DistributedSchedService::GetInstance().InitWifiStateListener();
112    DistributedSchedService::GetInstance().GetFormMgrProxy();
113    DistributedSchedService::GetInstance().ProcessFreeInstallOffline(devId);
114    DistributedSchedService::GetInstance().ProcessCalleeOffline(devId);
115}
116
117void DisconnectRemoteAbilityInnerFuzzTest(const uint8_t* data, size_t size)
118{
119    if ((data == nullptr) || (size < sizeof(int32_t))) {
120        return;
121    }
122    FuzzUtil::MockPermission();
123    MessageParcel dataParcel;
124    MessageParcel reply;
125    MessageOption option;
126    sptr<IRemoteObject> connect(new MockDistributedSched());
127    int32_t int32Data = *(reinterpret_cast<const int32_t*>(data));
128    uint32_t uint32Data = *(reinterpret_cast<const uint32_t*>(data));
129
130    PARCEL_WRITE_HELPER_NORET(dataParcel, RemoteObject, connect);
131    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
132    PARCEL_WRITE_HELPER_NORET(dataParcel, Uint32, uint32Data);
133    DistributedSchedService::GetInstance().DisconnectRemoteAbilityInner(dataParcel, reply);
134
135    std::string networkId(reinterpret_cast<const char*>(data), size);
136    std::string bundleName(reinterpret_cast<const char*>(data), size);
137    DistributedSchedService::GetInstance().IsRemoteInstall(networkId, bundleName);
138    DistributedSchedService::GetInstance().GetContinueInfo(networkId, networkId);
139}
140
141void StartContinuationInnerFuzzTest(const uint8_t* data, size_t size)
142{
143    if ((data == nullptr) || (size < sizeof(int32_t))) {
144        return;
145    }
146    FuzzUtil::MockPermission();
147    MessageParcel dataParcel;
148    MessageParcel reply;
149    MessageOption option;
150    Want want;
151    int32_t missionId = *(reinterpret_cast<const int32_t*>(data));
152    int32_t callerUid = *(reinterpret_cast<const int32_t*>(data));
153    int32_t status = *(reinterpret_cast<const int32_t*>(data));
154    uint32_t accessToken = *(reinterpret_cast<const int32_t*>(data));
155
156    dataParcel.WriteParcelable(&want);
157    dataParcel.WriteInt32(missionId);
158    dataParcel.WriteInt32(callerUid);
159    dataParcel.WriteInt32(status);
160    dataParcel.WriteUint32(accessToken);
161    DistributedSchedService::GetInstance().StartContinuationInner(dataParcel, reply);
162    DistributedSchedService::GetInstance().StartAbility(want, callerUid);
163    DistributedSchedService::GetInstance().GetAppManager();
164}
165
166void NotifyCompleteContinuationInnerFuzzTest(const uint8_t* data, size_t size)
167{
168    if ((data == nullptr) || (size < sizeof(int32_t))) {
169        return;
170    }
171    FuzzUtil::MockPermission();
172    std::string devId(reinterpret_cast<const char*>(data), size);
173    bool isSuccess = *(reinterpret_cast<const bool*>(data));
174    MessageParcel dataParcel;
175    MessageParcel reply;
176    MessageOption option;
177    int32_t sessionId = *(reinterpret_cast<const int32_t*>(data));
178
179    dataParcel.WriteString16(Str8ToStr16(devId));
180    dataParcel.WriteInt32(sessionId);
181    dataParcel.WriteBool(isSuccess);
182    DistributedSchedService::GetInstance().NotifyCompleteContinuationInner(dataParcel, reply);
183}
184
185void ContinueMissionInnerFuzzTest(const uint8_t* data, size_t size)
186{
187    if ((data == nullptr) || (size < sizeof(int32_t))) {
188        return;
189    }
190    FuzzUtil::MockPermission();
191    MessageParcel dataParcel;
192    MessageParcel reply;
193    MessageOption option;
194    int32_t int32Data = *(reinterpret_cast<const int32_t*>(data));
195    std::string str(reinterpret_cast<const char*>(data), size);
196    std::string deviceId(reinterpret_cast<const char*>(data), size);
197    std::string bundleName(reinterpret_cast<const char*>(data), size);
198    sptr<IRemoteObject> callback(new MockDistributedSched());
199    WantParams wantParams;
200
201    PARCEL_WRITE_HELPER_NORET(dataParcel, String, str);
202    PARCEL_WRITE_HELPER_NORET(dataParcel, String, str);
203    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
204    PARCEL_WRITE_HELPER_NORET(dataParcel, RemoteObject, callback);
205    PARCEL_WRITE_HELPER_NORET(dataParcel, Parcelable, &wantParams);
206    DistributedSchedService::GetInstance().ContinueMissionInner(dataParcel, reply);
207    DistributedSchedService::GetInstance().ContinueLocalMission(deviceId, int32Data, callback, wantParams);
208    DistributedSchedService::GetInstance().ContinueRemoteMission(deviceId, deviceId, int32Data, callback, wantParams);
209    DistributedSchedService::GetInstance().ContinueMission(deviceId, deviceId, int32Data, callback, wantParams);
210}
211
212void ContinueMissionOfBundleNameInnerFuzzTest(const uint8_t* data, size_t size)
213{
214    if ((data == nullptr) || (size < sizeof(int32_t))) {
215        return;
216    }
217    FuzzUtil::MockPermission();
218    MessageParcel dataParcel;
219    MessageParcel reply;
220    MessageOption option;
221    std::string str(reinterpret_cast<const char*>(data), size);
222    std::string deviceId(reinterpret_cast<const char*>(data), size);
223    std::string bundleName(reinterpret_cast<const char*>(data), size);
224    sptr<IRemoteObject> callback(new MockDistributedSched());
225    WantParams wantParams;
226
227    PARCEL_WRITE_HELPER_NORET(dataParcel, String, str);
228    PARCEL_WRITE_HELPER_NORET(dataParcel, String, str);
229    PARCEL_WRITE_HELPER_NORET(dataParcel, String, str);
230    PARCEL_WRITE_HELPER_NORET(dataParcel, RemoteObject, callback);
231    PARCEL_WRITE_HELPER_NORET(dataParcel, Parcelable, &wantParams);
232    DistributedSchedService::GetInstance().ContinueMissionOfBundleNameInner(dataParcel, reply);
233    DistributedSchedService::GetInstance().ContinueRemoteMission(deviceId, deviceId, bundleName,
234        callback, wantParams);
235    DistributedSchedService::GetInstance().ProcessContinueLocalMission(deviceId, deviceId, bundleName,
236        callback, wantParams);
237    DistributedSchedService::GetInstance().ProcessContinueRemoteMission(deviceId, deviceId, bundleName,
238        callback, wantParams);
239}
240
241void GetMissionInfosInnerFuzzTest(const uint8_t* data, size_t size)
242{
243    if ((data == nullptr) || (size < sizeof(int32_t))) {
244        return;
245    }
246    FuzzUtil::MockPermission();
247    MessageParcel dataParcel;
248    MessageParcel reply;
249    MessageOption option;
250    int32_t int32Data = *(reinterpret_cast<const int32_t*>(data));
251    std::string str(reinterpret_cast<const char*>(data), size);
252
253    PARCEL_WRITE_HELPER_NORET(dataParcel, String16, Str8ToStr16(str));
254    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
255    DistributedSchedService::GetInstance().GetMissionInfosInner(dataParcel, reply);
256}
257
258void RegisterMissionListenerInnerFuzzTest(const uint8_t* data, size_t size)
259{
260    if ((data == nullptr) || (size < sizeof(int32_t))) {
261        return;
262    }
263    FuzzUtil::MockPermission();
264    MessageParcel dataParcel;
265    MessageParcel reply;
266    MessageOption option;
267    Want want;
268    int32_t missionId = *(reinterpret_cast<const int32_t*>(data));
269    uint32_t uint32Data = *(reinterpret_cast<const uint32_t*>(data));
270    std::string str(reinterpret_cast<const char*>(data), size);
271    sptr<IRemoteObject> obj(new MockDistributedSched());
272
273    PARCEL_WRITE_HELPER_NORET(dataParcel, String16, Str8ToStr16(str));
274    PARCEL_WRITE_HELPER_NORET(dataParcel, RemoteObject, obj);
275    DistributedSchedService::GetInstance().RegisterMissionListenerInner(dataParcel, reply);
276    DistributedSchedService::GetInstance().ContinueLocalMissionDealFreeInstall(want, missionId, str, obj);
277    DistributedSchedService::GetInstance().ContinueAbilityWithTimeout(str, missionId, obj, uint32Data);
278}
279
280void UnRegisterMissionListenerInnerFuzzTest(const uint8_t* data, size_t size)
281{
282    if ((data == nullptr) || (size < sizeof(int32_t))) {
283        return;
284    }
285    FuzzUtil::MockPermission();
286    MessageParcel dataParcel;
287    MessageParcel reply;
288    MessageOption option;
289    std::string str(reinterpret_cast<const char*>(data), size);
290    sptr<IRemoteObject> obj(new MockDistributedSched());
291
292    PARCEL_WRITE_HELPER_NORET(dataParcel, String16, Str8ToStr16(str));
293    PARCEL_WRITE_HELPER_NORET(dataParcel, RemoteObject, obj);
294    DistributedSchedService::GetInstance().UnRegisterMissionListenerInner(dataParcel, reply);
295}
296
297void StartSyncRemoteMissionsInnerFuzzTest(const uint8_t* data, size_t size)
298{
299    if ((data == nullptr) || (size < sizeof(int32_t))) {
300        return;
301    }
302    FuzzUtil::MockPermission();
303    MessageParcel dataParcel;
304    MessageParcel reply;
305    MessageOption option;
306    bool boolData = *(reinterpret_cast<const bool*>(data));
307    int64_t int64Data = static_cast<int64_t>(GetU32Data(data, size));
308    std::string str(reinterpret_cast<const char*>(data), size);
309
310    PARCEL_WRITE_HELPER_NORET(dataParcel, String16, Str8ToStr16(str));
311    PARCEL_WRITE_HELPER_NORET(dataParcel, Bool, boolData);
312    PARCEL_WRITE_HELPER_NORET(dataParcel, Int64, int64Data);
313    DistributedSchedService::GetInstance().StartSyncRemoteMissionsInner(dataParcel, reply);
314}
315
316void StopSyncRemoteMissionsInnerFuzzTest(const uint8_t* data, size_t size)
317{
318    if ((data == nullptr) || (size < sizeof(int32_t))) {
319        return;
320    }
321    FuzzUtil::MockPermission();
322    MessageParcel dataParcel;
323    MessageParcel reply;
324    MessageOption option;
325    std::string str(reinterpret_cast<const char*>(data), size);
326
327    PARCEL_WRITE_HELPER_NORET(dataParcel, String16, Str8ToStr16(str));
328    DistributedSchedService::GetInstance().StopSyncRemoteMissionsInner(dataParcel, reply);
329
330    Want want;
331    CallerInfo callerInfo;
332    IDistributedSched::AccountInfo accountInfo;
333    int32_t flag = *(reinterpret_cast<const int32_t*>(data));
334    DistributedSchedService::GetInstance().CheckTargetPermission(want, callerInfo, accountInfo, flag, true);
335}
336
337void GetRemoteMissionSnapshotInfoInnerFuzzTest(const uint8_t* data, size_t size)
338{
339    if ((data == nullptr) || (size < sizeof(int32_t))) {
340        return;
341    }
342    FuzzUtil::MockPermission();
343    MessageParcel dataParcel;
344    MessageParcel reply;
345    MessageOption option;
346    std::string networkId(reinterpret_cast<const char*>(data), size);
347    int32_t missionId = *(reinterpret_cast<const int32_t*>(data));
348
349    dataParcel.WriteString(networkId);
350    dataParcel.WriteInt32(missionId);
351    DistributedSchedService::GetInstance().GetRemoteMissionSnapshotInfoInner(dataParcel, reply);
352    DistributedSchedService::GetInstance().DurationStart(networkId, networkId);
353}
354
355void StartRemoteAbilityByCallInnerFuzzTest(const uint8_t* data, size_t size)
356{
357    if ((data == nullptr) || (size < sizeof(int32_t))) {
358        return;
359    }
360    FuzzUtil::MockPermission();
361    MessageParcel dataParcel;
362    MessageParcel reply;
363    MessageOption option;
364    Want want;
365    sptr<IRemoteObject> obj(new MockDistributedSched());
366    int32_t int32Data = *(reinterpret_cast<const int32_t*>(data));
367    uint32_t uint32Data = *(reinterpret_cast<const uint32_t*>(data));
368
369    PARCEL_WRITE_HELPER_NORET(dataParcel, Parcelable, &want);
370    PARCEL_WRITE_HELPER_NORET(dataParcel, RemoteObject, obj);
371    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
372    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
373    PARCEL_WRITE_HELPER_NORET(dataParcel, Uint32, uint32Data);
374    DistributedSchedService::GetInstance().StartRemoteAbilityByCallInner(dataParcel, reply);
375    DistributedSchedService::GetInstance().SetWantForContinuation(want, int32Data);
376}
377
378void ReleaseRemoteAbilityInnerFuzzTest(const uint8_t* data, size_t size)
379{
380    if ((data == nullptr) || (size < sizeof(int32_t))) {
381        return;
382    }
383    FuzzUtil::MockPermission();
384    MessageParcel dataParcel;
385    MessageParcel reply;
386    MessageOption option;
387    sptr<IRemoteObject> connect(new MockDistributedSched());
388    Want want;
389    AppExecFwk::ElementName element;
390    CallerInfo callerInfo;
391    std::string deviceId(reinterpret_cast<const char*>(data), size);
392
393    PARCEL_WRITE_HELPER_NORET(dataParcel, RemoteObject, connect);
394    PARCEL_WRITE_HELPER_NORET(dataParcel, Parcelable, &element);
395    DistributedSchedService::GetInstance().ReleaseRemoteAbilityInner(dataParcel, reply);
396    callerInfo.uid = ONE;
397    DistributedSchedService::GetInstance().CheckDistributedConnectLocked(callerInfo);
398    DistributedSchedService::GetInstance().DecreaseConnectLocked(ONE);
399    DistributedSchedService::GetInstance().RemoteConnectAbilityMappingLocked(connect, deviceId,
400        deviceId, element, callerInfo, TargetComponent::HARMONY_COMPONENT);
401    DistributedSchedService::GetInstance().NotifyProcessDied(deviceId, callerInfo, TargetComponent::HARMONY_COMPONENT);
402    DistributedSchedService::GetInstance().ProcessDeviceOffline(deviceId);
403}
404
405void GetDistributedComponentListInnerFuzzTest(const uint8_t* data, size_t size)
406{
407    if ((data == nullptr) || (size < sizeof(int32_t))) {
408        return;
409    }
410    FuzzUtil::MockPermission();
411    MessageParcel dataParcel;
412    MessageParcel reply;
413    MessageOption option;
414
415    DistributedSchedService::GetInstance().GetDistributedComponentListInner(dataParcel, reply);
416}
417
418void StartRemoteFreeInstallInnerFuzzTest(const uint8_t* data, size_t size)
419{
420    if ((data == nullptr) || (size < sizeof(int32_t))) {
421        return;
422    }
423    FuzzUtil::MockPermission();
424    MessageParcel dataParcel;
425    MessageParcel reply;
426    MessageOption option;
427    int32_t int32Data = *(reinterpret_cast<const int32_t*>(data));
428    uint32_t uint32Data = *(reinterpret_cast<const uint32_t*>(data));
429    sptr<IRemoteObject> obj(new MockDistributedSched());
430    Want want;
431
432    PARCEL_WRITE_HELPER_NORET(dataParcel, Parcelable, &want);
433    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
434    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
435    PARCEL_WRITE_HELPER_NORET(dataParcel, Uint32, uint32Data);
436    PARCEL_WRITE_HELPER_NORET(dataParcel, RemoteObject, obj);
437    DistributedSchedService::GetInstance().StartRemoteFreeInstallInner(dataParcel, reply);
438    DistributedSchedService::GetInstance().ProcessCallResult(obj, obj);
439}
440
441void StartRemoteShareFormInnerFuzzTest(const uint8_t* data, size_t size)
442{
443    if ((data == nullptr) || (size < sizeof(int32_t))) {
444        return;
445    }
446    FuzzUtil::MockPermission();
447    int32_t code = static_cast<uint32_t>(IDSchedInterfaceCode::START_REMOTE_SHARE_FORM);
448    MessageParcel dataParcel;
449    MessageParcel reply;
450    MessageOption option;
451    std::string str(reinterpret_cast<const char*>(data), size);
452    Want want;
453    dataParcel.WriteInterfaceToken(DMS_STUB_INTERFACE_TOKEN);
454    PARCEL_WRITE_HELPER_NORET(dataParcel, String, str);
455    PARCEL_WRITE_HELPER_NORET(dataParcel, Parcelable, &want);
456    DistributedSchedService::GetInstance().OnRemoteRequest(code, dataParcel, reply, option);
457}
458
459void StopRemoteExtensionAbilityInnerFuzzTest(const uint8_t* data, size_t size)
460{
461    if ((data == nullptr) || (size < sizeof(int32_t))) {
462        return;
463    }
464    FuzzUtil::MockPermission();
465    MessageParcel dataParcel;
466    MessageParcel reply;
467    MessageOption option;
468    Want want;
469    int32_t callerUid = *(reinterpret_cast<const int32_t*>(data));
470    int32_t serviceType = *(reinterpret_cast<const int32_t*>(data));
471    uint32_t accessToken = *(reinterpret_cast<const int32_t*>(data));
472    dataParcel.WriteParcelable(&want);
473    dataParcel.WriteInt32(callerUid);
474    dataParcel.WriteUint32(accessToken);
475    dataParcel.WriteInt32(serviceType);
476    DistributedSchedService::GetInstance().StopRemoteExtensionAbilityInner(dataParcel, reply);
477
478    CallerInfo callerInfo;
479    std::string localDeviceId(reinterpret_cast<const char*>(data), size);
480    DistributedSchedService::GetInstance().GetCallerInfo(localDeviceId, callerUid, accessToken, callerInfo);
481    DistributedSchedService::GetInstance().CheckDeviceIdFromRemote(localDeviceId, localDeviceId, localDeviceId);
482}
483
484void RegisterOnListenerInnerFuzzTest(const uint8_t* data, size_t size)
485{
486    if ((data == nullptr) || (size < sizeof(int32_t))) {
487        return;
488    }
489    FuzzUtil::MockPermission();
490    MessageParcel dataParcel;
491    MessageParcel reply;
492    MessageOption option;
493    std::string str(reinterpret_cast<const char*>(data), size);
494    sptr<IRemoteObject> obj(new MockDistributedSched());
495
496    PARCEL_WRITE_HELPER_NORET(dataParcel, String, str);
497    PARCEL_WRITE_HELPER_NORET(dataParcel, RemoteObject, obj);
498    DistributedSchedService::GetInstance().RegisterOnListenerInner(dataParcel, reply);
499    DistributedSchedService::GetInstance().HandleLocalCallerDied(obj);
500    DistributedSchedService::GetInstance().RemoveCallerComponent(obj);
501    DistributedSchedService::GetInstance().RemoveConnectAbilityInfo(str);
502    DistributedSchedService::GetInstance().DumpConnectInfo(str);
503}
504
505void RegisterOffListenerInnerFuzzTest(const uint8_t* data, size_t size)
506{
507    if ((data == nullptr) || (size < sizeof(int32_t))) {
508        return;
509    }
510    FuzzUtil::MockPermission();
511    MessageParcel dataParcel;
512    MessageParcel reply;
513    MessageOption option;
514    std::string str(reinterpret_cast<const char*>(data), size);
515    sptr<IRemoteObject> obj(new MockDistributedSched());
516
517    PARCEL_WRITE_HELPER_NORET(dataParcel, String, str);
518    PARCEL_WRITE_HELPER_NORET(dataParcel, RemoteObject, obj);
519    DistributedSchedService::GetInstance().RegisterOffListenerInner(dataParcel, reply);
520}
521
522void RegisterDSchedEventListenerInnerFuzzTest(const uint8_t* data, size_t size)
523{
524    if ((data == nullptr) || (size < sizeof(int32_t))) {
525        return;
526    }
527    FuzzUtil::MockPermission();
528    MessageParcel dataParcel;
529    MessageParcel reply;
530    MessageOption option;
531    uint8_t uint8Data = *(reinterpret_cast<const uint8_t*>(data));
532    sptr<IRemoteObject> obj(new MockDistributedSched());
533
534    PARCEL_WRITE_HELPER_NORET(dataParcel, Uint8, uint8Data);
535    PARCEL_WRITE_HELPER_NORET(dataParcel, RemoteObject, obj);
536    DistributedSchedService::GetInstance().RegisterDSchedEventListenerInner(dataParcel, reply);
537}
538
539void UnRegisterDSchedEventListenerInnerFuzzTest(const uint8_t* data, size_t size)
540{
541    if ((data == nullptr) || (size < sizeof(int32_t))) {
542        return;
543    }
544    FuzzUtil::MockPermission();
545    MessageParcel dataParcel;
546    MessageParcel reply;
547    MessageOption option;
548    uint8_t uint8Data = *(reinterpret_cast<const uint8_t*>(data));
549    sptr<IRemoteObject> obj(new MockDistributedSched());
550
551    PARCEL_WRITE_HELPER_NORET(dataParcel, Uint8, uint8Data);
552    PARCEL_WRITE_HELPER_NORET(dataParcel, RemoteObject, obj);
553    DistributedSchedService::GetInstance().UnRegisterDSchedEventListenerInner(dataParcel, reply);
554}
555
556void SetMissionContinueStateInnerFuzzTest(const uint8_t* data, size_t size)
557{
558    if ((data == nullptr) || (size < sizeof(int32_t))) {
559        return;
560    }
561    FuzzUtil::MockPermission();
562    MessageParcel dataParcel;
563    MessageParcel reply;
564    MessageOption option;
565    int32_t missionId = *(reinterpret_cast<const int32_t*>(data));
566    int32_t state = *(reinterpret_cast<const int32_t*>(data));
567    int32_t timeout = *(reinterpret_cast<const int32_t*>(data));
568
569    dataParcel.WriteInt32(missionId);
570    dataParcel.WriteInt32(state);
571    DistributedSchedService::GetInstance().SetMissionContinueStateInner(dataParcel, reply);
572    DistributedSchedService::GetInstance().RemoveContinuationTimeout(missionId);
573    DistributedSchedService::GetInstance().SetContinuationTimeout(missionId, timeout);
574    DistributedSchedService::GetInstance().GetContinuaitonDevice(missionId);
575}
576
577void StartAbilityFromRemoteInnerFuzzTest(const uint8_t* data, size_t size)
578{
579    if ((data == nullptr) || (size < sizeof(int32_t))) {
580        return;
581    }
582    FuzzUtil::MockPermission();
583    MessageParcel dataParcel;
584    MessageParcel reply;
585    MessageOption option;
586    DistributedWant dstbWant;
587    AppExecFwk::CompatibleAbilityInfo compatibleAbilityInfo;
588    int32_t int32Data = *(reinterpret_cast<const int32_t*>(data));
589    std::string str(reinterpret_cast<const char*>(data), size);
590    std::vector<std::string> strVector = {str};
591
592    PARCEL_WRITE_HELPER_NORET(dataParcel, Parcelable, &dstbWant);
593    PARCEL_WRITE_HELPER_NORET(dataParcel, Parcelable, &compatibleAbilityInfo);
594    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
595    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
596    PARCEL_WRITE_HELPER_NORET(dataParcel, String, str);
597    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
598    PARCEL_WRITE_HELPER_NORET(dataParcel, StringVector, strVector);
599    PARCEL_WRITE_HELPER_NORET(dataParcel, String, str);
600    DistributedSchedService::GetInstance().StartAbilityFromRemoteInner(dataParcel, reply);
601}
602
603void SendResultFromRemoteInnerFuzzTest(const uint8_t* data, size_t size)
604{
605    if ((data == nullptr) || (size < sizeof(int32_t))) {
606        return;
607    }
608    FuzzUtil::MockPermission();
609    MessageParcel dataParcel;
610    MessageParcel reply;
611    MessageOption option;
612    AppExecFwk::CompatibleAbilityInfo compatibleAbilityInfo;
613    int32_t int32Data = *(reinterpret_cast<const int32_t*>(data));
614    std::string str(reinterpret_cast<const char*>(data), size);
615    std::vector<std::string> strVector = {str};
616    DistributedWant dstbWant;
617
618    PARCEL_WRITE_HELPER_NORET(dataParcel, Parcelable, &dstbWant);
619    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
620    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
621    PARCEL_WRITE_HELPER_NORET(dataParcel, String, str);
622    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
623    PARCEL_WRITE_HELPER_NORET(dataParcel, StringVector, strVector);
624    PARCEL_WRITE_HELPER_NORET(dataParcel, String, str);
625    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
626    PARCEL_WRITE_HELPER_NORET(dataParcel, String, str);
627    DistributedSchedService::GetInstance().SendResultFromRemoteInner(dataParcel, reply);
628}
629
630void NotifyDSchedEventResultFromRemoteInnerFuzzTest(const uint8_t* data, size_t size)
631{
632    if ((data == nullptr) || (size < sizeof(int32_t))) {
633        return;
634    }
635    FuzzUtil::MockPermission();
636    MessageParcel dataParcel;
637    MessageParcel reply;
638    MessageOption option;
639    int32_t int32Data = *(reinterpret_cast<const int32_t*>(data));
640    std::string str(reinterpret_cast<const char*>(data), size);
641
642    PARCEL_WRITE_HELPER_NORET(dataParcel, String, str);
643    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
644    DistributedSchedService::GetInstance().NotifyDSchedEventResultFromRemoteInner(dataParcel, reply);
645}
646
647void NotifyContinuationResultFromRemoteInnerFuzzTest(const uint8_t* data, size_t size)
648{
649    if ((data == nullptr) || (size < sizeof(int32_t))) {
650        return;
651    }
652    FuzzUtil::MockPermission();
653    DmsContinueTime::GetInstance().Init();
654    MessageParcel dataParcel;
655    MessageParcel reply;
656    MessageOption option;
657    AppExecFwk::CompatibleAbilityInfo compatibleAbilityInfo;
658    bool boolData = *(reinterpret_cast<const bool*>(data));
659    int32_t int32Data = *(reinterpret_cast<const int32_t*>(data));
660    std::string str(reinterpret_cast<const char*>(data), size);
661
662    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
663    PARCEL_WRITE_HELPER_NORET(dataParcel, Bool, boolData);
664    PARCEL_WRITE_HELPER_NORET(dataParcel, String, str);
665    DistributedSchedService::GetInstance().NotifyContinuationResultFromRemoteInner(dataParcel, reply);
666}
667
668void ConnectAbilityFromRemoteInnerFuzzTest(const uint8_t* data, size_t size)
669{
670    if ((data == nullptr) || (size < sizeof(int32_t))) {
671        return;
672    }
673    FuzzUtil::MockPermission();
674    MessageParcel dataParcel;
675    MessageParcel reply;
676    MessageOption option;
677    AppExecFwk::CompatibleAbilityInfo compatibleAbilityInfo;
678    int32_t int32Data = *(reinterpret_cast<const int32_t*>(data));
679    std::string str(reinterpret_cast<const char*>(data), size);
680    std::vector<std::string> strVector = {str};
681    DistributedWant dstbWant;
682    const sptr<IRemoteObject> connect(new MockDistributedSched());
683
684    PARCEL_WRITE_HELPER_NORET(dataParcel, Parcelable, &dstbWant);
685    PARCEL_WRITE_HELPER_NORET(dataParcel, Parcelable, &compatibleAbilityInfo);
686    PARCEL_WRITE_HELPER_NORET(dataParcel, RemoteObject, connect);
687    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
688    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
689    PARCEL_WRITE_HELPER_NORET(dataParcel, String, str);
690    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
691    PARCEL_WRITE_HELPER_NORET(dataParcel, StringVector, strVector);
692    PARCEL_WRITE_HELPER_NORET(dataParcel, String, str);
693    PARCEL_WRITE_HELPER_NORET(dataParcel, String, str);
694    DistributedSchedService::GetInstance().ConnectAbilityFromRemoteInner(dataParcel, reply);
695}
696
697void DisconnectAbilityFromRemoteInnerFuzzTest(const uint8_t* data, size_t size)
698{
699    if ((data == nullptr) || (size < sizeof(int32_t))) {
700        return;
701    }
702    FuzzUtil::MockPermission();
703    MessageParcel dataParcel;
704    MessageParcel reply;
705    MessageOption option;
706    AppExecFwk::CompatibleAbilityInfo compatibleAbilityInfo;
707    int32_t int32Data = *(reinterpret_cast<const int32_t*>(data));
708    std::string str(reinterpret_cast<const char*>(data), size);
709
710    sptr<IRemoteObject> connect(new MockDistributedSched());
711    PARCEL_WRITE_HELPER_NORET(dataParcel, RemoteObject, connect);
712    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
713    PARCEL_WRITE_HELPER_NORET(dataParcel, String, str);
714    DistributedSchedService::GetInstance().DisconnectAbilityFromRemoteInner(dataParcel, reply);
715    DistributedSchedService::GetInstance().ProcessCallerDied(connect, int32Data);
716    DistributedSchedService::GetInstance().ProcessCalleeDied(connect);
717}
718
719void NotifyProcessDiedFromRemoteInnerFuzzTest(const uint8_t* data, size_t size)
720{
721    if ((data == nullptr) || (size < sizeof(int32_t))) {
722        return;
723    }
724    FuzzUtil::MockPermission();
725    MessageParcel dataParcel;
726    MessageParcel reply;
727    MessageOption option;
728    int32_t int32Data = *(reinterpret_cast<const int32_t*>(data));
729    std::string str(reinterpret_cast<const char*>(data), size);
730
731    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
732    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
733    PARCEL_WRITE_HELPER_NORET(dataParcel, String, str);
734    DistributedSchedService::GetInstance().NotifyProcessDiedFromRemoteInner(dataParcel, reply);
735}
736
737void GetContinueInfoInnerFuzzTest(const uint8_t* data, size_t size)
738{
739    if ((data == nullptr) || (size < sizeof(int32_t))) {
740        return;
741    }
742    FuzzUtil::MockPermission();
743    MessageParcel dataParcel;
744    MessageParcel reply;
745    MessageOption option;
746    std::string str(reinterpret_cast<const char*>(data), size);
747
748    PARCEL_WRITE_HELPER_NORET(dataParcel, String, str);
749    PARCEL_WRITE_HELPER_NORET(dataParcel, String, str);
750    DistributedSchedService::GetInstance().GetContinueInfoInner(dataParcel, reply);
751}
752
753void NotifyMissionsChangedFromRemoteInnerFuzzTest(const uint8_t* data, size_t size)
754{
755    if ((data == nullptr) || (size < sizeof(int32_t))) {
756        return;
757    }
758    FuzzUtil::MockPermission();
759    MessageParcel dataParcel;
760    MessageParcel reply;
761    MessageOption option;
762    int32_t int32Data = *(reinterpret_cast<const int32_t*>(data));
763    std::string str(reinterpret_cast<const char*>(data), size);
764    std::vector<DstbMissionInfo> missionInfos;
765    CallerInfo callerInfo;
766    DistributedWant dstbWant;
767
768    PARCEL_WRITE_HELPER_NORET(dataParcel, Parcelable, &dstbWant);
769    if (!DstbMissionInfo::WriteDstbMissionInfosToParcel(dataParcel, missionInfos)) {
770        return;
771    }
772    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
773    PARCEL_WRITE_HELPER_NORET(dataParcel, String, str);
774    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
775    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
776    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
777    DistributedSchedService::GetInstance().NotifyMissionsChangedFromRemoteInner(dataParcel, reply);
778}
779
780void ReleaseAbilityFromRemoteInnerFuzzTest(const uint8_t* data, size_t size)
781{
782    if ((data == nullptr) || (size < sizeof(int32_t))) {
783        return;
784    }
785    FuzzUtil::MockPermission();
786    MessageParcel dataParcel;
787    MessageParcel reply;
788    MessageOption option;
789    sptr<IRemoteObject> connect(new MockDistributedSched());
790    AppExecFwk::ElementName element;
791    Want want;
792    const CallerInfo callerInfo;
793    std::string str(reinterpret_cast<const char*>(data), size);
794    int32_t int32Data = *(reinterpret_cast<const int32_t*>(data));
795
796    PARCEL_WRITE_HELPER_NORET(dataParcel, RemoteObject, connect);
797    PARCEL_WRITE_HELPER_NORET(dataParcel, Parcelable, &element);
798    PARCEL_WRITE_HELPER_NORET(dataParcel, String, str);
799    PARCEL_WRITE_HELPER_NORET(dataParcel, String, str);
800    DistributedSchedService::GetInstance().ReleaseAbilityFromRemoteInner(dataParcel, reply);
801    DistributedSchedService::GetInstance().TryStartRemoteAbilityByCall(want, connect, callerInfo);
802    DistributedSchedService::GetInstance().SaveCallerComponent(want, connect, callerInfo);
803    DistributedSchedService::GetInstance().SaveConnectToken(want, connect);
804    DistributedSchedService::GetInstance().NotifyStateChanged(int32Data, element, connect);
805    DistributedSchedService::GetInstance().SetCleanMissionFlag(want, int32Data);
806}
807
808void NotifyStateChangedFromRemoteInnerFuzzTest(const uint8_t* data, size_t size)
809{
810    if ((data == nullptr) || (size < sizeof(int32_t))) {
811        return;
812    }
813    FuzzUtil::MockPermission();
814    MessageParcel dataParcel;
815    MessageParcel reply;
816    MessageOption option;
817    const AppExecFwk::ElementName element;
818    sptr<IRemoteObject> connect(new MockDistributedSched());
819    int32_t int32Data = *(reinterpret_cast<const int32_t*>(data));
820    std::string str(reinterpret_cast<const char*>(data), size);
821
822    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
823    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
824    PARCEL_WRITE_HELPER_NORET(dataParcel, Parcelable, &element);
825    DistributedSchedService::GetInstance().NotifyStateChangedFromRemoteInner(dataParcel, reply);
826    DistributedSchedService::GetInstance().NotifyApp(connect, element, int32Data);
827}
828
829void StartFreeInstallFromRemoteInnerFuzzTest(const uint8_t* data, size_t size)
830{
831    if ((data == nullptr) || (size < sizeof(int32_t))) {
832        return;
833    }
834    FuzzUtil::MockPermission();
835    MessageParcel dataParcel;
836    MessageParcel reply;
837    MessageOption option;
838    int32_t int32Data = *(reinterpret_cast<const int32_t*>(data));
839    int64_t int64Data = static_cast<int64_t>(GetU32Data(data, size));
840    std::string str(reinterpret_cast<const char*>(data), size);
841    std::vector<std::string> strVector = {str};
842    DistributedWant dstbWant;
843
844    PARCEL_WRITE_HELPER_NORET(dataParcel, Parcelable, &dstbWant);
845    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
846    PARCEL_WRITE_HELPER_NORET(dataParcel, String, str);
847    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
848    PARCEL_WRITE_HELPER_NORET(dataParcel, StringVector, strVector);
849    PARCEL_WRITE_HELPER_NORET(dataParcel, String, str);
850    PARCEL_WRITE_HELPER_NORET(dataParcel, Int64, int64Data);
851    PARCEL_WRITE_HELPER_NORET(dataParcel, Parcelable, &dstbWant);
852    PARCEL_WRITE_HELPER_NORET(dataParcel, String, str);
853    DistributedSchedService::GetInstance().StartFreeInstallFromRemoteInner(dataParcel, reply);
854}
855
856void NotifyCompleteFreeInstallFromRemoteInnerFuzzTest(const uint8_t* data, size_t size)
857{
858    if ((data == nullptr) || (size < sizeof(int32_t))) {
859        return;
860    }
861    FuzzUtil::MockPermission();
862    MessageParcel dataParcel;
863    MessageParcel reply;
864    MessageOption option;
865    int32_t int32Data = *(reinterpret_cast<const int32_t*>(data));
866    int64_t int64Data = static_cast<int64_t>(GetU32Data(data, size));
867
868    PARCEL_WRITE_HELPER_NORET(dataParcel, Int64, int64Data);
869    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
870    DistributedSchedService::GetInstance().NotifyCompleteFreeInstallFromRemoteInner(dataParcel, reply);
871}
872
873void GetDSchedEventInfoInnerFuzzTest(const uint8_t* data, size_t size)
874{
875    if ((data == nullptr) || (size < sizeof(int32_t))) {
876        return;
877    }
878    FuzzUtil::MockPermission();
879    MessageParcel dataParcel;
880    MessageParcel reply;
881    MessageOption option;
882    int32_t int32Data = *(reinterpret_cast<const int32_t*>(data)) % DMS_ALL;
883
884    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
885    DistributedSchedService::GetInstance().GetDSchedEventInfoInner(dataParcel, reply);
886}
887
888void StartAbilityByCallFromRemoteInnerFuzzTest(const uint8_t* data, size_t size)
889{
890    if ((data == nullptr) || (size < sizeof(int32_t))) {
891        return;
892    }
893    FuzzUtil::MockPermission();
894    MessageParcel dataParcel;
895    MessageParcel reply;
896    MessageOption option;
897    int32_t int32Data = *(reinterpret_cast<const int32_t*>(data));
898    std::string str(reinterpret_cast<const char*>(data), size);
899    std::vector<std::string> strVector = {str};
900    DistributedWant dstbWant;
901    sptr<IRemoteObject> connect(new MockDistributedSched());
902
903    PARCEL_WRITE_HELPER_NORET(dataParcel, RemoteObject, connect);
904    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
905    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
906    PARCEL_WRITE_HELPER_NORET(dataParcel, String, str);
907    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
908    PARCEL_WRITE_HELPER_NORET(dataParcel, StringVector, strVector);
909    PARCEL_WRITE_HELPER_NORET(dataParcel, String, str);
910    PARCEL_WRITE_HELPER_NORET(dataParcel, String, str);
911    PARCEL_WRITE_HELPER_NORET(dataParcel, Parcelable, &dstbWant);
912    DistributedSchedService::GetInstance().StartAbilityByCallFromRemoteInner(dataParcel, reply);
913    DistributedSchedService::GetInstance().ProcessConnectDied(connect);
914    DistributedSchedService::GetInstance().DisconnectEachRemoteAbilityLocked(str, str, connect);
915}
916
917void StartSyncMissionsFromRemoteInnerFuzzTest(const uint8_t* data, size_t size)
918{
919    if ((data == nullptr) || (size < sizeof(int32_t))) {
920        return;
921    }
922    FuzzUtil::MockPermission();
923    MessageParcel dataParcel;
924    MessageParcel reply;
925    MessageOption option;
926    int32_t int32Data = *(reinterpret_cast<const int32_t*>(data));
927    std::string str(reinterpret_cast<const char*>(data), size);
928
929    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
930    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
931    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
932    PARCEL_WRITE_HELPER_NORET(dataParcel, String, str);
933    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
934    PARCEL_WRITE_HELPER_NORET(dataParcel, String, str);
935    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
936    DistributedSchedService::GetInstance().StartSyncMissionsFromRemoteInner(dataParcel, reply);
937}
938
939void StopSyncMissionsFromRemoteInnerFuzzTest(const uint8_t* data, size_t size)
940{
941    if ((data == nullptr) || (size < sizeof(int32_t))) {
942        return;
943    }
944    FuzzUtil::MockPermission();
945    MessageParcel dataParcel;
946    MessageParcel reply;
947    MessageOption option;
948    int32_t int32Data = *(reinterpret_cast<const int32_t*>(data));
949    std::string str(reinterpret_cast<const char*>(data), size);
950
951    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
952    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
953    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
954    PARCEL_WRITE_HELPER_NORET(dataParcel, String, str);
955    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
956    PARCEL_WRITE_HELPER_NORET(dataParcel, String, str);
957    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
958
959    DistributedSchedService::GetInstance().StopSyncMissionsFromRemoteInner(dataParcel, reply);
960}
961
962void StartShareFormFromRemoteInnerFuzzTest(const uint8_t* data, size_t size)
963{
964    if ((data == nullptr) || (size < sizeof(int32_t))) {
965        return;
966    }
967    FuzzUtil::MockPermission();
968    MessageParcel dataParcel;
969    MessageParcel reply;
970    std::string str(reinterpret_cast<const char*>(data), size);
971    DistributedWant dstbWant;
972    PARCEL_WRITE_HELPER_NORET(dataParcel, String, str);
973    PARCEL_WRITE_HELPER_NORET(dataParcel, Parcelable, &dstbWant);
974    DistributedSchedService::GetInstance().StartShareFormFromRemoteInner(dataParcel, reply);
975}
976
977void StopExtensionAbilityFromRemoteInnerFuzzTest(const uint8_t* data, size_t size)
978{
979    if ((data == nullptr) || (size < sizeof(int32_t))) {
980        return;
981    }
982    FuzzUtil::MockPermission();
983    MessageParcel dataParcel;
984    MessageParcel reply;
985    MessageOption option;
986    int32_t int32Data = *(reinterpret_cast<const int32_t*>(data));
987    std::string str(reinterpret_cast<const char*>(data), size);
988    std::vector<std::string> strVector = {str};
989    DistributedWant dstbWant;
990
991    PARCEL_WRITE_HELPER_NORET(dataParcel, Parcelable, &dstbWant);
992    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
993    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
994    PARCEL_WRITE_HELPER_NORET(dataParcel, String, str);
995    PARCEL_WRITE_HELPER_NORET(dataParcel, Int32, int32Data);
996    PARCEL_WRITE_HELPER_NORET(dataParcel, StringVector, strVector);
997    PARCEL_WRITE_HELPER_NORET(dataParcel, String, str);
998    PARCEL_WRITE_HELPER_NORET(dataParcel, String, str);
999    DistributedSchedService::GetInstance().StopExtensionAbilityFromRemoteInner(dataParcel, reply);
1000}
1001}
1002}
1003
1004/* Fuzzer entry point */
1005extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
1006{
1007    OHOS::DistributedSchedule::StartRemoteAbilityInnerFuzzTest(data, size);
1008    OHOS::DistributedSchedule::ConnectRemoteAbilityInnerFuzzTest(data, size);
1009    OHOS::DistributedSchedule::DisconnectRemoteAbilityInnerFuzzTest(data, size);
1010    OHOS::DistributedSchedule::StartContinuationInnerFuzzTest(data, size);
1011    OHOS::DistributedSchedule::NotifyCompleteContinuationInnerFuzzTest(data, size);
1012    OHOS::DistributedSchedule::ContinueMissionInnerFuzzTest(data, size);
1013    OHOS::DistributedSchedule::ContinueMissionOfBundleNameInnerFuzzTest(data, size);
1014    OHOS::DistributedSchedule::GetMissionInfosInnerFuzzTest(data, size);
1015    OHOS::DistributedSchedule::RegisterMissionListenerInnerFuzzTest(data, size);
1016    OHOS::DistributedSchedule::UnRegisterMissionListenerInnerFuzzTest(data, size);
1017    OHOS::DistributedSchedule::StartSyncRemoteMissionsInnerFuzzTest(data, size);
1018    OHOS::DistributedSchedule::StopSyncRemoteMissionsInnerFuzzTest(data, size);
1019    OHOS::DistributedSchedule::GetRemoteMissionSnapshotInfoInnerFuzzTest(data, size);
1020    OHOS::DistributedSchedule::StartRemoteAbilityByCallInnerFuzzTest(data, size);
1021    OHOS::DistributedSchedule::ReleaseRemoteAbilityInnerFuzzTest(data, size);
1022    OHOS::DistributedSchedule::GetDistributedComponentListInnerFuzzTest(data, size);
1023    OHOS::DistributedSchedule::StartRemoteFreeInstallInnerFuzzTest(data, size);
1024    OHOS::DistributedSchedule::StartRemoteShareFormInnerFuzzTest(data, size);
1025    OHOS::DistributedSchedule::StopRemoteExtensionAbilityInnerFuzzTest(data, size);
1026    OHOS::DistributedSchedule::RegisterOnListenerInnerFuzzTest(data, size);
1027    OHOS::DistributedSchedule::RegisterOffListenerInnerFuzzTest(data, size);
1028    OHOS::DistributedSchedule::RegisterDSchedEventListenerInnerFuzzTest(data, size);
1029    OHOS::DistributedSchedule::UnRegisterDSchedEventListenerInnerFuzzTest(data, size);
1030    OHOS::DistributedSchedule::SetMissionContinueStateInnerFuzzTest(data, size);
1031    OHOS::DistributedSchedule::StartAbilityFromRemoteInnerFuzzTest(data, size);
1032    OHOS::DistributedSchedule::SendResultFromRemoteInnerFuzzTest(data, size);
1033    OHOS::DistributedSchedule::NotifyDSchedEventResultFromRemoteInnerFuzzTest(data, size);
1034    OHOS::DistributedSchedule::NotifyContinuationResultFromRemoteInnerFuzzTest(data, size);
1035    OHOS::DistributedSchedule::ConnectAbilityFromRemoteInnerFuzzTest(data, size);
1036    OHOS::DistributedSchedule::DisconnectAbilityFromRemoteInnerFuzzTest(data, size);
1037    OHOS::DistributedSchedule::NotifyProcessDiedFromRemoteInnerFuzzTest(data, size);
1038    OHOS::DistributedSchedule::GetContinueInfoInnerFuzzTest(data, size);
1039    OHOS::DistributedSchedule::NotifyMissionsChangedFromRemoteInnerFuzzTest(data, size);
1040    OHOS::DistributedSchedule::ReleaseAbilityFromRemoteInnerFuzzTest(data, size);
1041    OHOS::DistributedSchedule::NotifyStateChangedFromRemoteInnerFuzzTest(data, size);
1042    OHOS::DistributedSchedule::StartFreeInstallFromRemoteInnerFuzzTest(data, size);
1043    OHOS::DistributedSchedule::NotifyCompleteFreeInstallFromRemoteInnerFuzzTest(data, size);
1044    OHOS::DistributedSchedule::GetDSchedEventInfoInnerFuzzTest(data, size);
1045    OHOS::DistributedSchedule::StartAbilityByCallFromRemoteInnerFuzzTest(data, size);
1046    OHOS::DistributedSchedule::StartSyncMissionsFromRemoteInnerFuzzTest(data, size);
1047    OHOS::DistributedSchedule::StopSyncMissionsFromRemoteInnerFuzzTest(data, size);
1048    OHOS::DistributedSchedule::StartShareFormFromRemoteInnerFuzzTest(data, size);
1049    OHOS::DistributedSchedule::StopExtensionAbilityFromRemoteInnerFuzzTest(data, size);
1050    return 0;
1051}