From b4db340f7b5d780eafeca664464630eb49285af8 Mon Sep 17 00:00:00 2001 From: torrizo Date: Mon, 15 Apr 2024 05:40:15 +0000 Subject: [PATCH 01/19] add fuzz Signed-off-by: torrizo --- interfaces/ipc/test/fuzztest/BUILD.gn | 32 +++++++ .../distributedinputstub_fuzzer/BUILD.gn | 87 +++++++++++++++++++ .../distributedinputstub_fuzzer/corpus/init | 14 +++ .../distributedinputstub_fuzzer.cpp | 67 ++++++++++++++ .../distributedinputstub_fuzzer.h | 23 +++++ .../distributedinputstub_fuzzer/project.xml | 25 ++++++ 6 files changed, 248 insertions(+) create mode 100644 interfaces/ipc/test/fuzztest/BUILD.gn create mode 100644 interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/BUILD.gn create mode 100644 interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/corpus/init create mode 100644 interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/distributedinputstub_fuzzer.cpp create mode 100644 interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/distributedinputstub_fuzzer.h create mode 100644 interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/project.xml diff --git a/interfaces/ipc/test/fuzztest/BUILD.gn b/interfaces/ipc/test/fuzztest/BUILD.gn new file mode 100644 index 0000000..55b7910 --- /dev/null +++ b/interfaces/ipc/test/fuzztest/BUILD.gn @@ -0,0 +1,32 @@ +# Copyright (c) 2022-2023 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +group("fuzztest") { + testonly = true + + deps = [ + "dinputconfigdh_fuzzer:fuzztest", + "dinputinitsink_fuzzer:fuzztest", + "dinputinitsource_fuzzer:fuzztest", + "dinputonsessionclosed_fuzzer:fuzztest", + "dinputonsessionopend_fuzzer:fuzztest", + "dinputreleasesink_fuzzer:fuzztest", + "dinputreleasesource_fuzzer:fuzztest", + "dinputsubscribelocaldh_fuzzer:fuzztest", + "distributedinputclient_fuzzer:fuzztest", + "distributedinputkit_fuzzer:fuzztest", + "distributedinputsinktransport_fuzzer:fuzztest", + "distributedinputsourcetransport_fuzzer:fuzztest", + "distributedinputtransportbase_fuzzer:fuzztest", + ] +} diff --git a/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/BUILD.gn b/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/BUILD.gn new file mode 100644 index 0000000..cbc3341 --- /dev/null +++ b/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/BUILD.gn @@ -0,0 +1,87 @@ +# Copyright (c) 2022-2024 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +#####################hydra-fuzz################### +import("//build/config/features.gni") +import("//build/test.gni") +import( + "//foundation/distributedhardware/distributed_input/distributedinput.gni") + +##############################fuzztest########################################## +ohos_fuzztest("DistributedInputTransportBaseFuzzTest") { + module_out_path = fuzz_test_path + + fuzz_config_file = "${distributedinput_path}/test/fuzztest/distributedinputtransportbase_fuzzer" + + include_dirs = [ + "${av_transport_path}/common/include", + "${services_source_path}/transport/include", + "${distributedinput_path}/services/transportbase/include", + "${common_path}/include", + "${fwk_interfaces_path}/include", + "${service_common}/include", + "${services_source_path}/inputinject/include", + "${services_source_path}/transport/include", + "${dfx_utils_path}/include", + "${utils_path}/include", + "${frameworks_path}/include", + "${distributedinput_path}/inputdevicehandler/include", + ] + + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + ] + + sources = [ + "${distributedinput_path}/services/transportbase/src/distributed_input_transport_base.cpp", + "distributed_input_transport_base_fuzzer.cpp", + ] + + deps = [ + "${dfx_utils_path}:libdinput_dfx_utils", + "${distributedinput_path}/services/transportbase:libdinput_trans_base", + "${services_source_path}/inputinject:libdinput_inject", + "${utils_path}:libdinput_utils", + "//third_party/libevdev:libevdev", + ] + + external_deps = [ + "c_utils:utils", + "distributed_hardware_fwk:distributedhardwareutils", + "distributed_hardware_fwk:libdhfwk_sdk", + "dsoftbus:softbus_client", + "eventhandler:libeventhandler", + "hilog:libhilog", + "hitrace:hitrace_meter", + "ipc:ipc_core", + "json:nlohmann_json_static", + "safwk:system_ability_fwk", + ] + + defines = [ + "HI_LOG_ENABLE", + "DH_LOG_TAG=\"DistributedInputTransportBaseFuzzTest\"", + "LOG_DOMAIN=0xD004120", + ] +} + +############################################################################### +group("fuzztest") { + testonly = true + + deps = [ ":DistributedInputTransportBaseFuzzTest" ] +} +############################################################################### diff --git a/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/corpus/init b/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/corpus/init new file mode 100644 index 0000000..c49c21a --- /dev/null +++ b/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/corpus/init @@ -0,0 +1,14 @@ +# Copyright (c) 2022 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +FUZZ \ No newline at end of file diff --git a/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/distributedinputstub_fuzzer.cpp b/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/distributedinputstub_fuzzer.cpp new file mode 100644 index 0000000..ffeac36 --- /dev/null +++ b/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/distributedinputstub_fuzzer.cpp @@ -0,0 +1,67 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "distributed_input_transport_base_fuzzer.h" + +#include +#include +#include +#include +#include +#include + +#include + +#include "constants_dinput.h" +#include "distributed_input_transport_base.h" + +namespace OHOS { +namespace DistributedHardware { +void StartSessionFuzzTest(const uint8_t *data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(int32_t))) { + return; + } + + std::string remoteDevId(reinterpret_cast(data), size); + + const uint32_t sleepTimeUs = 100 * 1000; + usleep(sleepTimeUs); + DistributedInput::DistributedInputTransportBase::GetInstance().StartSession(remoteDevId); + DistributedInput::DistributedInputTransportBase::GetInstance().StopSession(remoteDevId); +} + +void OnBytesReceivedFuzzTest(const uint8_t *data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(int32_t))) { + return; + } + + int32_t sessionId = *(reinterpret_cast(data)); + const char *msg = reinterpret_cast(data); + uint32_t dataLen = static_cast(size); + DistributedInput::DistributedInputTransportBase::GetInstance().OnBytesReceived(sessionId, msg, dataLen); +} +} // namespace DistributedHardware +} // namespace OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) +{ + /* Run your code on data */ + OHOS::DistributedHardware::StartSessionFuzzTest(data, size); + OHOS::DistributedHardware::OnBytesReceivedFuzzTest(data, size); + return 0; +} \ No newline at end of file diff --git a/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/distributedinputstub_fuzzer.h b/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/distributedinputstub_fuzzer.h new file mode 100644 index 0000000..68935e2 --- /dev/null +++ b/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/distributedinputstub_fuzzer.h @@ -0,0 +1,23 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +#ifndef DISTRIBUTED_INPUT_TRANSPORT_BASE_FUZZER_H +#define DISTRIBUTED_INPUT_TRANSPORT_BASE_FUZZER_H + +#define FUZZ_PROJECT_NAME "distributedinputtransportbase_fuzzer" + +#endif // DISTRIBUTED_INPUT_TRANSPORT_BASE_FUZZER_H + diff --git a/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/project.xml b/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/project.xml new file mode 100644 index 0000000..6e8ad2c --- /dev/null +++ b/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + -- Gitee From e95fe7402836910eb85e4a267e6e75ef7ad340b0 Mon Sep 17 00:00:00 2001 From: torrizo Date: Mon, 15 Apr 2024 06:07:18 +0000 Subject: [PATCH 02/19] update interfaces/ipc/test/fuzztest/BUILD.gn. Signed-off-by: torrizo --- interfaces/ipc/test/fuzztest/BUILD.gn | 18 +++--------------- 1 file changed, 3 insertions(+), 15 deletions(-) diff --git a/interfaces/ipc/test/fuzztest/BUILD.gn b/interfaces/ipc/test/fuzztest/BUILD.gn index 55b7910..7b779fc 100644 --- a/interfaces/ipc/test/fuzztest/BUILD.gn +++ b/interfaces/ipc/test/fuzztest/BUILD.gn @@ -1,4 +1,4 @@ -# Copyright (c) 2022-2023 Huawei Device Co., Ltd. +# Copyright (c) 2024 Huawei Device Co., Ltd. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at @@ -15,18 +15,6 @@ group("fuzztest") { testonly = true deps = [ - "dinputconfigdh_fuzzer:fuzztest", - "dinputinitsink_fuzzer:fuzztest", - "dinputinitsource_fuzzer:fuzztest", - "dinputonsessionclosed_fuzzer:fuzztest", - "dinputonsessionopend_fuzzer:fuzztest", - "dinputreleasesink_fuzzer:fuzztest", - "dinputreleasesource_fuzzer:fuzztest", - "dinputsubscribelocaldh_fuzzer:fuzztest", - "distributedinputclient_fuzzer:fuzztest", - "distributedinputkit_fuzzer:fuzztest", - "distributedinputsinktransport_fuzzer:fuzztest", - "distributedinputsourcetransport_fuzzer:fuzztest", - "distributedinputtransportbase_fuzzer:fuzztest", + "distributedinputstub_fuzzer:fuzztest", ] -} +} \ No newline at end of file -- Gitee From 54f3fa0fa4d4de146cd12fc4b0cfd84eb07c2126 Mon Sep 17 00:00:00 2001 From: torrizo Date: Mon, 15 Apr 2024 06:08:22 +0000 Subject: [PATCH 03/19] update interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/BUILD.gn. Signed-off-by: torrizo --- .../distributedinputstub_fuzzer/BUILD.gn | 85 +++++++++++++++---- 1 file changed, 69 insertions(+), 16 deletions(-) diff --git a/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/BUILD.gn b/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/BUILD.gn index cbc3341..c062ec8 100644 --- a/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/BUILD.gn +++ b/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/BUILD.gn @@ -1,4 +1,4 @@ -# Copyright (c) 2022-2024 Huawei Device Co., Ltd. +# Copyright (c) 2021-2024 Huawei Device Co., Ltd. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at @@ -18,24 +18,34 @@ import( "//foundation/distributedhardware/distributed_input/distributedinput.gni") ##############################fuzztest########################################## -ohos_fuzztest("DistributedInputTransportBaseFuzzTest") { +ohos_fuzztest("DistributedInputStubFuzzTest") { module_out_path = fuzz_test_path - fuzz_config_file = "${distributedinput_path}/test/fuzztest/distributedinputtransportbase_fuzzer" + fuzz_config_file = "${ipc_path}/test/fuzztest/distributedinputstub_fuzzer" include_dirs = [ "${av_transport_path}/common/include", - "${services_source_path}/transport/include", - "${distributedinput_path}/services/transportbase/include", + "${innerkits_path}/include", + "${innerkits_path}/ipc/include", + "${innerkits_path}/src", + "${ipc_path}/include", + "${ipc_path}/src", + "${services_source_path}/sourcemanager/include", + "${frameworks_path}/include", + "${distributedinput_path}/inputdevicehandler/include", "${common_path}/include", - "${fwk_interfaces_path}/include", + "${services_state_path}/include", "${service_common}/include", "${services_source_path}/inputinject/include", "${services_source_path}/transport/include", "${dfx_utils_path}/include", "${utils_path}/include", - "${frameworks_path}/include", - "${distributedinput_path}/inputdevicehandler/include", + "${fwk_interfaces_path}/include", + "${fwk_interfaces_path}/include/ipc", + "${common_path}/test/mock", + "${distributedinput_path}/services/transportbase/include", + "${distributedinput_path}/utils/include", + "${distributedinput_path}/services/state/include", ] cflags = [ @@ -44,36 +54,79 @@ ohos_fuzztest("DistributedInputTransportBaseFuzzTest") { "-Wno-unused-variable", "-fno-omit-frame-pointer", ] - sources = [ + "${common_path}/include/input_hub.cpp", + "${common_path}/test/mock/socket_mock.cpp", + "${common_path}/test/mock/softbus_bus_center_mock.cpp", "${distributedinput_path}/services/transportbase/src/distributed_input_transport_base.cpp", - "distributed_input_transport_base_fuzzer.cpp", + "${distributedinput_path}/utils/src/dinput_context.cpp", + "${distributedinput_path}/utils/src/dinput_utils_tool.cpp", + "${ipc_path}/src/add_white_list_infos_call_back_proxy.cpp", + "${ipc_path}/src/add_white_list_infos_call_back_stub.cpp", + "${ipc_path}/src/del_white_list_infos_call_back_proxy.cpp", + "${ipc_path}/src/del_white_list_infos_call_back_stub.cpp", + "${ipc_path}/src/distributed_input_sink_proxy.cpp", + "${ipc_path}/src/distributed_input_sink_stub.cpp", + "${ipc_path}/src/distributed_input_source_proxy.cpp", + "${ipc_path}/src/distributed_input_source_stub.cpp", + "${ipc_path}/src/get_sink_screen_infos_call_back_proxy.cpp", + "${ipc_path}/src/get_sink_screen_infos_call_back_stub.cpp", + "${ipc_path}/src/prepare_d_input_call_back_proxy.cpp", + "${ipc_path}/src/prepare_d_input_call_back_stub.cpp", + "${ipc_path}/src/register_d_input_call_back_proxy.cpp", + "${ipc_path}/src/register_d_input_call_back_stub.cpp", + "${ipc_path}/src/start_d_input_call_back_proxy.cpp", + "${ipc_path}/src/start_d_input_call_back_stub.cpp", + "${ipc_path}/src/stop_d_input_call_back_proxy.cpp", + "${ipc_path}/src/stop_d_input_call_back_stub.cpp", + "${ipc_path}/src/unprepare_d_input_call_back_proxy.cpp", + "${ipc_path}/src/unprepare_d_input_call_back_stub.cpp", + "${ipc_path}/src/unregister_d_input_call_back_proxy.cpp", + "${ipc_path}/src/unregister_d_input_call_back_stub.cpp", + "${services_source_path}/inputinject/src/distributed_input_inject.cpp", + "${services_source_path}/inputinject/src/distributed_input_node_manager.cpp", + "${services_source_path}/inputinject/src/virtual_device.cpp", + "${services_source_path}/sourcemanager/src/dinput_source_listener.cpp", + "${services_source_path}/sourcemanager/src/dinput_source_manager_event_handler.cpp", + "${services_source_path}/sourcemanager/src/distributed_input_source_event_handler.cpp", + "${services_source_path}/sourcemanager/src/distributed_input_source_manager.cpp", + "${services_source_path}/sourcemanager/src/distributed_input_source_sa_cli_mgr.cpp", + "${services_source_path}/transport/src/distributed_input_source_transport.cpp", + "distributedinputstub_fuzzer.cpp", ] deps = [ "${dfx_utils_path}:libdinput_dfx_utils", - "${distributedinput_path}/services/transportbase:libdinput_trans_base", - "${services_source_path}/inputinject:libdinput_inject", + "${distributedinput_path}/services/state:libdinput_sink_state", + "${innerkits_path}:libdinput_sdk", + "${services_source_path}/transport:libdinput_source_trans", "${utils_path}:libdinput_utils", "//third_party/libevdev:libevdev", ] external_deps = [ + "access_token:libaccesstoken_sdk", + "access_token:libnativetoken", + "access_token:libtoken_setproc", + "access_token:libtokenid_sdk", "c_utils:utils", "distributed_hardware_fwk:distributedhardwareutils", "distributed_hardware_fwk:libdhfwk_sdk", - "dsoftbus:softbus_client", "eventhandler:libeventhandler", + "hicollie:libhicollie", "hilog:libhilog", + "hisysevent:libhisysevent", "hitrace:hitrace_meter", "ipc:ipc_core", "json:nlohmann_json_static", + "openssl:libcrypto_shared", "safwk:system_ability_fwk", + "samgr:samgr_proxy", ] defines = [ "HI_LOG_ENABLE", - "DH_LOG_TAG=\"DistributedInputTransportBaseFuzzTest\"", + "DH_LOG_TAG=\"DistributedInputStubFuzzTest\"", "LOG_DOMAIN=0xD004120", ] } @@ -82,6 +135,6 @@ ohos_fuzztest("DistributedInputTransportBaseFuzzTest") { group("fuzztest") { testonly = true - deps = [ ":DistributedInputTransportBaseFuzzTest" ] + deps = [ ":DistributedInputStubFuzzTest" ] } -############################################################################### +############################################################################### \ No newline at end of file -- Gitee From 9c4f47304fbb29adbd4b87afefd2b5e9b8f51138 Mon Sep 17 00:00:00 2001 From: torrizo Date: Mon, 15 Apr 2024 06:09:05 +0000 Subject: [PATCH 04/19] update interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/distributedinputstub_fuzzer.h. Signed-off-by: torrizo --- .../distributedinputstub_fuzzer.h | 85 +++++++++++++++++-- 1 file changed, 80 insertions(+), 5 deletions(-) diff --git a/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/distributedinputstub_fuzzer.h b/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/distributedinputstub_fuzzer.h index 68935e2..a4fbdbd 100644 --- a/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/distributedinputstub_fuzzer.h +++ b/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/distributedinputstub_fuzzer.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 Huawei Device Co., Ltd. + * Copyright (c) 2024 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -13,11 +13,86 @@ * limitations under the License. */ +#ifndef TEST_AVTRANSCALLBACKNOTIFY_FUZZER_H +#define TEST_AVTRANSCALLBACKNOTIFY_FUZZER_H -#ifndef DISTRIBUTED_INPUT_TRANSPORT_BASE_FUZZER_H -#define DISTRIBUTED_INPUT_TRANSPORT_BASE_FUZZER_H +#define FUZZ_PROJECT_NAME "distributedinputstub_fuzzer.cpp" -#define FUZZ_PROJECT_NAME "distributedinputtransportbase_fuzzer" +#endif -#endif // DISTRIBUTED_INPUT_TRANSPORT_BASE_FUZZER_H +#define private public +#define protected public +#include "constants_dinput.h" +#include "dinput_errcode.h" +#include "distributed_input_sink_stub.h" +#include "distributed_input_source_stub.h" +#undef private +#undef protected + +namespace OHOS { +namespace DistributedHardware { + +class DistributedInputSinkStubFuzz : public + OHOS::DistributedHardware::DistributedInput::DistributedInputSinkStub { +public: + DistributedInputSinkStubFuzz() = default; + virtual ~DistributedInputSinkStubFuzz() = default; + int32_t Init(); + int32_t Release(); + int32_t RegisterGetSinkScreenInfosCallback(sptr callback); + int32_t NotifyStartDScreen(const DistributedInput::SrcScreenInfo &remoteCtrlInfo); + int32_t NotifyStopDScreen(const std::string &srcScreenInfoKey); + int32_t RegisterSharingDhIdListener(sptr sharingDhIdListener); +}; + +class DInputSourceCallBackStubFuzz : public + OHOS::DistributedHardware::DistributedInput::DistributedInputSourceStub { +public: + DInputSourceCallBackStubFuzz() = default; + virtual ~DInputSourceCallBackStubFuzz() = default; + int32_t Init(); + int32_t Release() ; + int32_t RegisterDistributedHardware( + const std::string &devId, const std::string &dhId, const std::string ¶meters, + sptr callback); + int32_t UnregisterDistributedHardware( + const std::string &devId, const std::string &dhId, sptr callback); + int32_t PrepareRemoteInput(const std::string &deviceId, sptr callback); + int32_t UnprepareRemoteInput(const std::string &deviceId, + sptr callback); + int32_t StartRemoteInput( + const std::string &deviceId, const uint32_t &inputTypes, + sptr callback); + int32_t StopRemoteInput( + const std::string &deviceId, const uint32_t &inputTypes, + sptr callback); + int32_t StartRemoteInput(const std::string &srcId, const std::string &sinkId, const uint32_t &inputTypes, + sptr callback); + int32_t StopRemoteInput(const std::string &srcId, const std::string &sinkId, const uint32_t &inputTypes, + sptr callback); + int32_t PrepareRemoteInput(const std::string &srcId, const std::string &sinkId, + sptr callback); + int32_t UnprepareRemoteInput(const std::string &srcId, const std::string &sinkId, + sptr callback); + int32_t StartRemoteInput(const std::string &sinkId, const std::vector &dhIds, + sptr callback); + int32_t StopRemoteInput(const std::string &sinkId, const std::vector &dhIds, + sptr callback); + int32_t StartRemoteInput(const std::string &srcId, const std::string &sinkId, + const std::vector &dhIds, sptr callback); + int32_t StopRemoteInput(const std::string &srcId, const std::string &sinkId, + const std::vector &dhIds, sptr callback); + + int32_t RegisterAddWhiteListCallback(sptr addWhiteListCallback); + int32_t RegisterDelWhiteListCallback(sptr delWhiteListCallback); + int32_t RegisterSimulationEventListener(sptr listener); + int32_t UnregisterSimulationEventListener(sptr listener); + int32_t RegisterSessionStateCb(sptr callback); + int32_t UnregisterSessionStateCb(); + void OnResult(const std::string &deviceId, const std::string &strJson); + std::string deviceId_; + std::string strJson_; +}; +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file -- Gitee From b42a062dfec739b2e51e89637e64816f26d2b98f Mon Sep 17 00:00:00 2001 From: torrizo Date: Mon, 15 Apr 2024 06:09:34 +0000 Subject: [PATCH 05/19] update interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/distributedinputstub_fuzzer.cpp. Signed-off-by: torrizo --- .../distributedinputstub_fuzzer.cpp | 940 +++++++++++++++++- 1 file changed, 913 insertions(+), 27 deletions(-) diff --git a/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/distributedinputstub_fuzzer.cpp b/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/distributedinputstub_fuzzer.cpp index ffeac36..ac1aa4c 100644 --- a/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/distributedinputstub_fuzzer.cpp +++ b/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/distributedinputstub_fuzzer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Copyright (c) 2024 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -13,55 +13,941 @@ * limitations under the License. */ -#include "distributed_input_transport_base_fuzzer.h" +#include "distributedinputstub_fuzzer.h" -#include -#include -#include -#include -#include -#include - -#include - -#include "constants_dinput.h" -#include "distributed_input_transport_base.h" +#include "add_white_list_infos_call_back_stub.h" +#include "del_white_list_infos_call_back_stub.h" +#include "get_sink_screen_infos_call_back_stub.h" +#include "input_node_listener_stub.h" +#include "prepare_d_input_call_back_stub.h" +#include "register_d_input_call_back_stub.h" +#include "register_session_state_callback_stub.h" +#include "sharing_dhid_listener_stub.h" +#include "simulation_event_listener_stub.h" +#include "start_d_input_call_back_stub.h" +#include "start_stop_d_inputs_call_back_stub.h" +#include "start_stop_result_call_back_stub.h" +#include "stop_d_input_call_back_stub.h" +#include "unprepare_d_input_call_back_stub.h" +#include "unregister_d_input_call_back_stub.h" namespace OHOS { namespace DistributedHardware { -void StartSessionFuzzTest(const uint8_t *data, size_t size) + +class MyAddWhiteListInfosCallbackStub : public DistributedInput::AddWhiteListInfosCallbackStub { +public: + void OnResult(const std::string &deviceId, const std::string &strJson) override + { + return; + } +}; + +void AddWhiteListInfosCallbackStubFuzzTest(const uint8_t *data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(int32_t))) { + return; + } + MessageParcel pdata; + MessageParcel reply; + MessageOption option; + pdata.WriteInterfaceToken(DistributedInput::AddWhiteListInfosCallbackStub::GetDescriptor()); + uint32_t code = *(reinterpret_cast(data)); + if (code == (uint32_t)DistributedInput::IAddWhiteListInfosCallback::Message::RESULT) { + uint32_t tag = *(reinterpret_cast(data)); + std::string value(reinterpret_cast(data), size); + pdata.WriteUint32(tag); + pdata.WriteString(value); + } else { + int32_t fd = *(reinterpret_cast(data)); + int32_t len = *(reinterpret_cast(data)); + std::string name(reinterpret_cast(data), size); + pdata.WriteFileDescriptor(fd); + pdata.WriteInt32(len); + pdata.WriteString(name); + } + sptr addWhiteListInfos(new (std::nothrow) + MyAddWhiteListInfosCallbackStub()); + addWhiteListInfos->OnRemoteRequest(code, pdata, reply, option); +} + +class MyDelWhiteListInfosCallbackStub : public DistributedInput::DelWhiteListInfosCallbackStub { +public: + void OnResult(const std::string &deviceId) override + { + return; + } +}; + +void DelWhiteListInfosCallbackStubFuzzTest(const uint8_t *data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(int32_t))) { + return; + } + MessageParcel pdata; + MessageParcel reply; + MessageOption option; + uint32_t code = *(reinterpret_cast(data)); + pdata.WriteInterfaceToken(DistributedInput::DelWhiteListInfosCallbackStub::GetDescriptor()); + if (code == (uint32_t)DistributedInput::IDelWhiteListInfosCallback::Message::RESULT) { + uint32_t tag = *(reinterpret_cast(data)); + std::string value(reinterpret_cast(data), size); + pdata.WriteUint32(tag); + pdata.WriteString(value); + } else { + int32_t fd = *(reinterpret_cast(data)); + int32_t len = *(reinterpret_cast(data)); + std::string name(reinterpret_cast(data), size); + pdata.WriteFileDescriptor(fd); + pdata.WriteInt32(len); + pdata.WriteString(name); + } + + sptr delWhiteListInfos(new (std::nothrow) + MyDelWhiteListInfosCallbackStub()); + delWhiteListInfos->OnRemoteRequest(code, pdata, reply, option); +} + +int32_t DistributedInputSinkStubFuzz::Init() +{ + return DistributedInput::DH_SUCCESS; +} + +int32_t DistributedInputSinkStubFuzz::Release() +{ + return DistributedInput::DH_SUCCESS; +} + +int32_t DistributedInputSinkStubFuzz::RegisterGetSinkScreenInfosCallback( + sptr callback) +{ + (void)callback; + return DistributedInput::DH_SUCCESS; +} + +int32_t DistributedInputSinkStubFuzz::NotifyStartDScreen( + const DistributedInput::SrcScreenInfo &remoteCtrlInfo) +{ + (void)remoteCtrlInfo; + return DistributedInput::DH_SUCCESS; +} + +int32_t DistributedInputSinkStubFuzz::NotifyStopDScreen( + const std::string &srcScreenInfoKey) +{ + (void)srcScreenInfoKey; + return DistributedInput::DH_SUCCESS; +} + +int32_t DistributedInputSinkStubFuzz::RegisterSharingDhIdListener( + sptr sharingDhIdListener) +{ + (void)sharingDhIdListener; + return DistributedInput::DH_SUCCESS; +} + +void DistributedInputSinkStubFuzzTest(const uint8_t *data, size_t size) { if ((data == nullptr) || (size < sizeof(int32_t))) { return; } + MessageParcel pdata; + MessageParcel reply; + MessageOption option; + pdata.WriteInterfaceToken(DistributedInput::DistributedInputSinkStub::GetDescriptor()); + uint32_t code = *(reinterpret_cast(data)); + uint32_t type = *(reinterpret_cast(data)); + std::string content(reinterpret_cast(data), size); + std::string devId(reinterpret_cast(data), size); + pdata.WriteUint32(type); + pdata.WriteString(content); + pdata.WriteString(devId); + + sptr distributedInputSinkStub(new (std::nothrow) + DistributedInputSinkStubFuzz()); + distributedInputSinkStub->HasEnableDHPermission(); + distributedInputSinkStub->OnRemoteRequest(code, pdata, reply, option); + distributedInputSinkStub->InitInner(pdata, reply, option); + distributedInputSinkStub->ReleaseInner(pdata, reply, option); + distributedInputSinkStub->NotifyStartDScreenInner(pdata, reply, option); + distributedInputSinkStub->NotifyStopDScreenInner(pdata, reply, option); + distributedInputSinkStub->RegisterSharingDhIdListenerInner(pdata, reply, option); + distributedInputSinkStub->RegisterGetSinkScreenInfosInner(pdata, reply, option); +} + +int32_t DInputSourceCallBackStubFuzz::Init() +{ + return DistributedInput::DH_SUCCESS; +} + +int32_t DInputSourceCallBackStubFuzz::Release() +{ + return DistributedInput::DH_SUCCESS; +} + +int32_t DInputSourceCallBackStubFuzz::RegisterDistributedHardware( + const std::string &devId, const std::string &dhId, const std::string ¶meters, + sptr callback) +{ + (void)devId; + (void)dhId; + (void)parameters; + (void)callback; + return DistributedInput::DH_SUCCESS; +} + +int32_t DInputSourceCallBackStubFuzz::UnregisterDistributedHardware( + const std::string &devId, const std::string &dhId, + sptr callback) +{ + (void)devId; + (void)dhId; + (void)callback; + return DistributedInput::DH_SUCCESS; +} + +int32_t DInputSourceCallBackStubFuzz::PrepareRemoteInput( + const std::string &deviceId, sptr callback) +{ + (void)deviceId; + (void)callback; + return DistributedInput::DH_SUCCESS; +} + +int32_t DInputSourceCallBackStubFuzz::UnprepareRemoteInput( + const std::string &deviceId, sptr callback) +{ + (void)deviceId; + (void)callback; + return DistributedInput::DH_SUCCESS; +} - std::string remoteDevId(reinterpret_cast(data), size); +int32_t DInputSourceCallBackStubFuzz::StartRemoteInput( + const std::string &deviceId, const uint32_t &inputTypes, sptr callback) +{ + (void)deviceId; + (void)inputTypes; + (void)callback; + return DistributedInput::DH_SUCCESS; +} + +int32_t DInputSourceCallBackStubFuzz::StopRemoteInput( + const std::string &deviceId, const uint32_t &inputTypes, sptr callback) +{ + (void)deviceId; + (void)inputTypes; + (void)callback; + return DistributedInput::DH_SUCCESS; +} + +int32_t DInputSourceCallBackStubFuzz::StartRemoteInput( + const std::string &srcId, const std::string &sinkId, const uint32_t &inputTypes, + sptr callback) +{ + (void)srcId; + (void)sinkId; + (void)inputTypes; + (void)callback; + return DistributedInput::DH_SUCCESS; +} + +int32_t DInputSourceCallBackStubFuzz::StopRemoteInput( + const std::string &srcId, const std::string &sinkId, const uint32_t &inputTypes, + sptr callback) +{ + (void)srcId; + (void)sinkId; + (void)inputTypes; + (void)callback; + return DistributedInput::DH_SUCCESS; +} + +int32_t DInputSourceCallBackStubFuzz::PrepareRemoteInput( + const std::string &srcId, const std::string &sinkId, + sptr callback) +{ + (void)srcId; + (void)sinkId; + (void)callback; + return DistributedInput::DH_SUCCESS; +} + +int32_t DInputSourceCallBackStubFuzz::UnprepareRemoteInput( + const std::string &srcId, const std::string &sinkId, + sptr callback) +{ + (void)srcId; + (void)sinkId; + (void)callback; + return DistributedInput::DH_SUCCESS; +} + +int32_t DInputSourceCallBackStubFuzz::StartRemoteInput( + const std::string &sinkId, const std::vector &dhIds, + sptr callback) +{ + (void)sinkId; + (void)dhIds; + (void)callback; + return DistributedInput::DH_SUCCESS; +} + +int32_t DInputSourceCallBackStubFuzz::StopRemoteInput( + const std::string &sinkId, const std::vector &dhIds, + sptr callback) +{ + (void)sinkId; + (void)dhIds; + (void)callback; + return DistributedInput::DH_SUCCESS; +} + +int32_t DInputSourceCallBackStubFuzz::StartRemoteInput( + const std::string &srcId, const std::string &sinkId, + const std::vector &dhIds, sptr callback) +{ + (void)srcId; + (void)sinkId; + (void)dhIds; + (void)callback; + return DistributedInput::DH_SUCCESS; +} + +int32_t DInputSourceCallBackStubFuzz::StopRemoteInput( + const std::string &srcId, const std::string &sinkId, + const std::vector &dhIds, sptr callback) +{ + (void)srcId; + (void)sinkId; + (void)dhIds; + (void)callback; + return DistributedInput::DH_SUCCESS; +} + +int32_t DInputSourceCallBackStubFuzz::RegisterAddWhiteListCallback( + sptr addWhiteListCallback) +{ + (void)addWhiteListCallback; + return DistributedInput::DH_SUCCESS; +} + +int32_t DInputSourceCallBackStubFuzz::RegisterDelWhiteListCallback( + sptr delWhiteListCallback) +{ + (void)delWhiteListCallback; + return DistributedInput::DH_SUCCESS; +} + +int32_t DInputSourceCallBackStubFuzz::RegisterSimulationEventListener( + sptr listener) +{ + (void)listener; + return DistributedInput::DH_SUCCESS; +} + +int32_t DInputSourceCallBackStubFuzz::UnregisterSimulationEventListener( + sptr listener) +{ + (void)listener; + return DistributedInput::DH_SUCCESS; +} + +int32_t DInputSourceCallBackStubFuzz::RegisterSessionStateCb( + sptr callback) +{ + (void)callback; + return DistributedInput::DH_SUCCESS; +} - const uint32_t sleepTimeUs = 100 * 1000; - usleep(sleepTimeUs); - DistributedInput::DistributedInputTransportBase::GetInstance().StartSession(remoteDevId); - DistributedInput::DistributedInputTransportBase::GetInstance().StopSession(remoteDevId); +int32_t DInputSourceCallBackStubFuzz::UnregisterSessionStateCb() +{ + return DistributedInput::DH_SUCCESS; } -void OnBytesReceivedFuzzTest(const uint8_t *data, size_t size) +void DInputSourceCallBackStubFuzz::OnResult(const std::string &deviceId, + const std::string &strJson) +{ + deviceId_ = deviceId; + strJson_ = strJson; +} + +void DistributedInputSourceStubFuzzTest(const uint8_t *data, size_t size) { if ((data == nullptr) || (size < sizeof(int32_t))) { return; } + MessageParcel pdata; + MessageParcel reply; + MessageOption option; + pdata.WriteInterfaceToken(DistributedInput::DistributedInputSourceStub::GetDescriptor()); + uint32_t code = *(reinterpret_cast(data)); + uint32_t type = *(reinterpret_cast(data)); + std::string content(reinterpret_cast(data), size); + std::string devId(reinterpret_cast(data), size); + pdata.WriteUint32(type); + pdata.WriteString(content); + pdata.WriteString(devId); + + sptr distributedInputSourceStub(new (std::nothrow) + DInputSourceCallBackStubFuzz()); + distributedInputSourceStub->RegRespFunMap(); + distributedInputSourceStub->HasEnableDHPermission(); + distributedInputSourceStub->HasAccessDHPermission(); + distributedInputSourceStub->HandleInitDistributedHardware(reply); + distributedInputSourceStub->HandleReleaseDistributedHardware(reply); + distributedInputSourceStub->HandleRegisterDistributedHardware(pdata, reply); + distributedInputSourceStub->HandleUnregisterDistributedHardware(pdata, reply); + distributedInputSourceStub->HandlePrepareRemoteInput(pdata, reply); + distributedInputSourceStub->HandleUnprepareRemoteInput(pdata, reply); + distributedInputSourceStub->HandleStartRemoteInput(pdata, reply); + distributedInputSourceStub->HandleStopRemoteInput(pdata, reply); + distributedInputSourceStub->HandleStartRelayTypeRemoteInput(pdata, reply); + distributedInputSourceStub->HandleStopRelayTypeRemoteInput(pdata, reply); + distributedInputSourceStub->HandlePrepareRelayRemoteInput(pdata, reply); + distributedInputSourceStub->HandleUnprepareRelayRemoteInput(pdata, reply); + distributedInputSourceStub->HandleStartDhidRemoteInput(pdata, reply); + distributedInputSourceStub->HandleStopDhidRemoteInput(pdata, reply); + distributedInputSourceStub->HandleStartRelayDhidRemoteInput(pdata, reply); + distributedInputSourceStub->HandleStopRelayDhidRemoteInput(pdata, reply); + distributedInputSourceStub->HandleRegisterAddWhiteListCallback(pdata, reply); + distributedInputSourceStub->HandleRegisterDelWhiteListCallback(pdata, reply); + distributedInputSourceStub->HandleRegisterSimulationEventListener(pdata, reply); + distributedInputSourceStub->HandleUnregisterSimulationEventListener(pdata, reply); + distributedInputSourceStub->HandleRegisterSessionStateCb(pdata, reply); + distributedInputSourceStub->HandleUnregisterSessionStateCb(pdata, reply); + distributedInputSourceStub->OnRemoteRequest(code, pdata, reply, option); +} + +class MyGetSinkScreenInfosCallbackStub : public DistributedInput::GetSinkScreenInfosCallbackStub { +public: + void OnResult(const std::string &deviceId) override + { + return; + } +}; - int32_t sessionId = *(reinterpret_cast(data)); - const char *msg = reinterpret_cast(data); - uint32_t dataLen = static_cast(size); - DistributedInput::DistributedInputTransportBase::GetInstance().OnBytesReceived(sessionId, msg, dataLen); +void GetSinkScreenInfosCallbackStubFuzzTest(const uint8_t *data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(int32_t))) { + return; + } + MessageParcel pdata; + MessageParcel reply; + MessageOption option; + uint32_t code = *(reinterpret_cast(data)); + pdata.WriteInterfaceToken(DistributedInput::GetSinkScreenInfosCallbackStub::GetDescriptor()); + if (code == (uint32_t)DistributedInput::IGetSinkScreenInfosCallback::Message::RESULT) { + uint32_t tag = *(reinterpret_cast(data)); + std::string value(reinterpret_cast(data), size); + pdata.WriteUint32(tag); + pdata.WriteString(value); + } else { + int32_t fd = *(reinterpret_cast(data)); + int32_t len = *(reinterpret_cast(data)); + std::string name(reinterpret_cast(data), size); + pdata.WriteFileDescriptor(fd); + pdata.WriteInt32(len); + pdata.WriteString(name); + } + + sptr getSinkScreenInfosCbStub(new (std::nothrow) + MyGetSinkScreenInfosCallbackStub()); + getSinkScreenInfosCbStub->OnRemoteRequest(code, pdata, reply, option); +} + +class MyInputNodeListenerStub : public DistributedInput::InputNodeListenerStub { +public: + void OnNodeOnLine(const std::string srcDevId, const std::string sinkDevId, + const std::string sinkNodeId, const std::string sinkNodeDesc) override + { + return; + } + + void OnNodeOffLine(const std::string srcDevId, const std::string sinkDevId, + const std::string sinkNodeId) override + { + return; + } +}; + +void InputNodeListenerStubFuzzTest(const uint8_t *data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(int32_t))) { + return; + } + MessageParcel pdata; + MessageParcel reply; + MessageOption option; + uint32_t code = *(reinterpret_cast(data)); + pdata.WriteInterfaceToken(DistributedInput::InputNodeListenerStub::GetDescriptor()); + if (code == (uint32_t)DistributedInput::InputNodeListener::Message::RESULT_ON) { + uint32_t tag = *(reinterpret_cast(data)); + std::string value(reinterpret_cast(data), size); + pdata.WriteUint32(tag); + pdata.WriteString(value); + } else if(code == (uint32_t)DistributedInput::InputNodeListener::Message::RESULT_OFF) { + int32_t fd = *(reinterpret_cast(data)); + int32_t len = *(reinterpret_cast(data)); + std::string name(reinterpret_cast(data), size); + pdata.WriteFileDescriptor(fd); + pdata.WriteInt32(len); + pdata.WriteString(name); + } else { + uint32_t type = *(reinterpret_cast(data)); + std::string content(reinterpret_cast(data), size); + std::string devId(reinterpret_cast(data), size); + pdata.WriteUint32(type); + pdata.WriteString(content); + pdata.WriteString(devId); + } + + sptr inputNodeListenerStub(new (std::nothrow) + MyInputNodeListenerStub()); + inputNodeListenerStub->OnRemoteRequest(code, pdata, reply, option); +} + +class MyPrepareDInputCallbackStub : public DistributedInput::PrepareDInputCallbackStub { +public: + void OnResult(const std::string &devId, const int32_t &status) override + { + return; + } +}; + +void PrepareDInputCallbackStubFuzzTest(const uint8_t *data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(int32_t))) { + return; + } + MessageParcel pdata; + MessageParcel reply; + MessageOption option; + uint32_t code = *(reinterpret_cast(data)); + pdata.WriteInterfaceToken(DistributedInput::PrepareDInputCallbackStub::GetDescriptor()); + if (code == (uint32_t)DistributedInput::IPrepareDInputCallback::Message::RESULT) { + uint32_t tag = *(reinterpret_cast(data)); + std::string value(reinterpret_cast(data), size); + pdata.WriteUint32(tag); + pdata.WriteString(value); + } else { + int32_t fd = *(reinterpret_cast(data)); + int32_t len = *(reinterpret_cast(data)); + std::string name(reinterpret_cast(data), size); + pdata.WriteFileDescriptor(fd); + pdata.WriteInt32(len); + pdata.WriteString(name); + } + sptr prepareDInputCallbackStub(new (std::nothrow) + MyPrepareDInputCallbackStub()); + prepareDInputCallbackStub->OnRemoteRequest(code, pdata, reply, option); +} + +class MyRegisterDInputCallbackStub : public DistributedInput::RegisterDInputCallbackStub { +public: + void OnResult(const std::string &devId, const std::string &dhId, const int32_t &status) override + { + return; + } +}; + +void RegisterDInputCallbackStubFuzzTest(const uint8_t *data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(int32_t))) { + return; + } + MessageParcel pdata; + MessageParcel reply; + MessageOption option; + uint32_t code = *(reinterpret_cast(data)); + pdata.WriteInterfaceToken(DistributedInput::RegisterDInputCallbackStub::GetDescriptor()); + if (code == (uint32_t)DistributedInput::IRegisterDInputCallback::Message::RESULT) { + uint32_t tag = *(reinterpret_cast(data)); + std::string value(reinterpret_cast(data), size); + pdata.WriteUint32(tag); + pdata.WriteString(value); + } else { + int32_t fd = *(reinterpret_cast(data)); + int32_t len = *(reinterpret_cast(data)); + std::string name(reinterpret_cast(data), size); + pdata.WriteFileDescriptor(fd); + pdata.WriteInt32(len); + pdata.WriteString(name); + } + sptr registerDInputCallbackStub(new (std::nothrow) + MyRegisterDInputCallbackStub()); + registerDInputCallbackStub->OnRemoteRequest(code, pdata, reply, option); +} + +class MyRegisterSessionStateCallbackStub : public DistributedInput::RegisterSessionStateCallbackStub { +public: + void OnResult(const std::string &devId, const uint32_t status) override + { + return; + } +}; + +void RegisterSessionStateCallbackStubFuzzTest(const uint8_t *data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(int32_t))) { + return; + } + MessageParcel pdata; + MessageParcel reply; + MessageOption option; + uint32_t code = *(reinterpret_cast(data)); + pdata.WriteInterfaceToken(DistributedInput::RegisterSessionStateCallbackStub::GetDescriptor()); + if (code == (uint32_t)DistributedInput::ISessionStateCallback::Message::RESULT) { + uint32_t tag = *(reinterpret_cast(data)); + std::string value(reinterpret_cast(data), size); + pdata.WriteUint32(tag); + pdata.WriteString(value); + } else { + int32_t fd = *(reinterpret_cast(data)); + int32_t len = *(reinterpret_cast(data)); + std::string name(reinterpret_cast(data), size); + pdata.WriteFileDescriptor(fd); + pdata.WriteInt32(len); + pdata.WriteString(name); + } + sptr registerSessionStateCbkStub(new (std::nothrow) + MyRegisterSessionStateCallbackStub()); + registerSessionStateCbkStub->OnRemoteRequest(code, pdata, reply, option); +} + +class MySharingDhIdListenerStub : public DistributedInput::SharingDhIdListenerStub { +public: + int32_t OnSharing(std::string dhId) override + { + return 0; + } + + int32_t OnNoSharing(std::string dhId) override + { + return 0; + } +}; + +void SharingDhIdListenerStubFuzzTest(const uint8_t *data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(int32_t))) { + return; + } + MessageParcel pdata; + MessageParcel reply; + MessageOption option; + uint32_t code = *(reinterpret_cast(data)); + pdata.WriteInterfaceToken(DistributedInput::SharingDhIdListenerStub::GetDescriptor()); + if (code == (uint32_t)DistributedInput::ISharingDhIdListener::Message::SHARING) { + uint32_t tag = *(reinterpret_cast(data)); + std::string value(reinterpret_cast(data), size); + pdata.WriteUint32(tag); + pdata.WriteString(value); + } else if(code == (uint32_t)DistributedInput::ISharingDhIdListener::Message::NO_SHARING) { + int32_t fd = *(reinterpret_cast(data)); + int32_t len = *(reinterpret_cast(data)); + std::string name(reinterpret_cast(data), size); + pdata.WriteFileDescriptor(fd); + pdata.WriteInt32(len); + pdata.WriteString(name); + } else { + uint32_t type = *(reinterpret_cast(data)); + std::string content(reinterpret_cast(data), size); + std::string devId(reinterpret_cast(data), size); + pdata.WriteUint32(type); + pdata.WriteString(content); + pdata.WriteString(devId); + } + sptr sharingDhIdListenerStub(new (std::nothrow) + MySharingDhIdListenerStub()); + sharingDhIdListenerStub->OnRemoteRequest(code, pdata, reply, option); +} + +class MySimulationEventListenerStub : public DistributedInput::SimulationEventListenerStub { +public: + int32_t OnSimulationEvent(uint32_t type, uint32_t code, int32_t value) override + { + return 0; + } +}; + +void SimulationEventListenerStubFuzzTest(const uint8_t *data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(int32_t))) { + return; + } + MessageParcel pdata; + MessageParcel reply; + MessageOption option; + uint32_t code = *(reinterpret_cast(data)); + pdata.WriteInterfaceToken(DistributedInput::SimulationEventListenerStub::GetDescriptor()); + if (code == (uint32_t)DistributedInput::ISimulationEventListener::Message::RESULT_ON) { + uint32_t tag = *(reinterpret_cast(data)); + std::string value(reinterpret_cast(data), size); + pdata.WriteUint32(tag); + pdata.WriteString(value); + } else { + int32_t fd = *(reinterpret_cast(data)); + int32_t len = *(reinterpret_cast(data)); + std::string name(reinterpret_cast(data), size); + pdata.WriteFileDescriptor(fd); + pdata.WriteInt32(len); + pdata.WriteString(name); + } + sptr simulationEventListenerStub(new (std::nothrow) + MySimulationEventListenerStub()); + simulationEventListenerStub->OnRemoteRequest(code, pdata, reply, option); +} + +class MyStartDInputCallbackStub : public DistributedInput::StartDInputCallbackStub { +public: + void OnResult(const std::string &devId, const uint32_t &inputTypes, const int32_t &status) override + { + return; + } +}; + +void StartDInputCallbackStubFuzzTest(const uint8_t *data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(int32_t))) { + return; + } + MessageParcel pdata; + MessageParcel reply; + MessageOption option; + uint32_t code = *(reinterpret_cast(data)); + pdata.WriteInterfaceToken(DistributedInput::StartDInputCallbackStub::GetDescriptor()); + if (code == (uint32_t)DistributedInput::IStartDInputCallback::Message::RESULT) { + uint32_t tag = *(reinterpret_cast(data)); + std::string value(reinterpret_cast(data), size); + pdata.WriteUint32(tag); + pdata.WriteString(value); + } else { + int32_t fd = *(reinterpret_cast(data)); + int32_t len = *(reinterpret_cast(data)); + std::string name(reinterpret_cast(data), size); + pdata.WriteFileDescriptor(fd); + pdata.WriteInt32(len); + pdata.WriteString(name); + } + sptr startDInputCallbackStub(new (std::nothrow) + MyStartDInputCallbackStub()); + startDInputCallbackStub->OnRemoteRequest(code, pdata, reply, option); +} + +class MyStartStopDInputsCallbackStub : public DistributedInput::StartStopDInputsCallbackStub { +public: + void OnResultDhids(const std::string &devId, const int32_t &status) override + { + return; + } +}; + +void StartStopDInputsCallbackStubFuzzTest(const uint8_t *data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(int32_t))) { + return; + } + MessageParcel pdata; + MessageParcel reply; + MessageOption option; + uint32_t code = *(reinterpret_cast(data)); + pdata.WriteInterfaceToken(DistributedInput::StartStopDInputsCallbackStub::GetDescriptor()); + if (code == (uint32_t)DistributedInput::IStartStopDInputsCallback::Message::RESULT_STRING) { + uint32_t tag = *(reinterpret_cast(data)); + std::string value(reinterpret_cast(data), size); + pdata.WriteUint32(tag); + pdata.WriteString(value); + } else { + int32_t fd = *(reinterpret_cast(data)); + int32_t len = *(reinterpret_cast(data)); + std::string name(reinterpret_cast(data), size); + pdata.WriteFileDescriptor(fd); + pdata.WriteInt32(len); + pdata.WriteString(name); + } + sptr startStopDInputsCallbackStub(new (std::nothrow) + MyStartStopDInputsCallbackStub()); + startStopDInputsCallbackStub->OnRemoteRequest(code, pdata, reply, option); +} + +class MyStartStopResultCallbackStub : public DistributedInput::StartStopResultCallbackStub { +public: + void OnStart(const std::string &srcId, const std::string &sinkId, + std::vector &dhIds) override + { + return; + } + void OnStop(const std::string &srcId, const std::string &sinkId, + std::vector &dhIds) override + { + return; + } +}; + +void StartStopResultCallbackStubFuzzTest(const uint8_t *data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(int32_t))) { + return; + } + MessageParcel pdata; + MessageParcel reply; + MessageOption option; + uint32_t code = *(reinterpret_cast(data)); + pdata.WriteInterfaceToken(DistributedInput::StartStopResultCallbackStub::GetDescriptor()); + if (code == (uint32_t)DistributedInput::IStartStopResultCallback::Message::RESULT_START) { + uint32_t tag = *(reinterpret_cast(data)); + std::string value(reinterpret_cast(data), size); + pdata.WriteUint32(tag); + pdata.WriteString(value); + } else if(code == (uint32_t)DistributedInput::IStartStopResultCallback::Message::RESULT_STOP) { + int32_t fd = *(reinterpret_cast(data)); + int32_t len = *(reinterpret_cast(data)); + std::string name(reinterpret_cast(data), size); + pdata.WriteFileDescriptor(fd); + pdata.WriteInt32(len); + pdata.WriteString(name); + } else { + uint32_t type = *(reinterpret_cast(data)); + std::string content(reinterpret_cast(data), size); + std::string devId(reinterpret_cast(data), size); + pdata.WriteUint32(type); + pdata.WriteString(content); + pdata.WriteString(devId); + } + sptr startStopResultCallbackStub(new (std::nothrow) + MyStartStopResultCallbackStub()); + startStopResultCallbackStub->OnRemoteRequest(code, pdata, reply, option); +} + +class MyStopDInputCallbackStub : public DistributedInput::StopDInputCallbackStub { +public: + void OnResult(const std::string &devId, const uint32_t &inputTypes, const int32_t &status) override + { + return; + } +}; + +void StopDInputCallbackStubFuzzTest(const uint8_t *data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(int32_t))) { + return; + } + MessageParcel pdata; + MessageParcel reply; + MessageOption option; + uint32_t code = *(reinterpret_cast(data)); + pdata.WriteInterfaceToken(DistributedInput::StopDInputCallbackStub::GetDescriptor()); + if (code == (uint32_t)DistributedInput::IStopDInputCallback::Message::RESULT) { + uint32_t tag = *(reinterpret_cast(data)); + std::string value(reinterpret_cast(data), size); + pdata.WriteUint32(tag); + pdata.WriteString(value); + } else { + int32_t fd = *(reinterpret_cast(data)); + int32_t len = *(reinterpret_cast(data)); + std::string name(reinterpret_cast(data), size); + pdata.WriteFileDescriptor(fd); + pdata.WriteInt32(len); + pdata.WriteString(name); + } + sptr stopDInputCallbackStub(new (std::nothrow) + MyStopDInputCallbackStub()); + stopDInputCallbackStub->OnRemoteRequest(code, pdata, reply, option); +} + +class MyUnprepareDInputCallbackStub : public DistributedInput::UnprepareDInputCallbackStub { +public: + void OnResult(const std::string &devId, const int32_t &status) override + { + return; + } +}; + +void UnprepareDInputCallbackStubFuzzTest(const uint8_t *data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(int32_t))) { + return; + } + MessageParcel pdata; + MessageParcel reply; + MessageOption option; + uint32_t code = *(reinterpret_cast(data)); + pdata.WriteInterfaceToken(DistributedInput::UnprepareDInputCallbackStub::GetDescriptor()); + if (code == (uint32_t)DistributedInput::IUnprepareDInputCallback::Message::RESULT) { + uint32_t tag = *(reinterpret_cast(data)); + std::string value(reinterpret_cast(data), size); + pdata.WriteUint32(tag); + pdata.WriteString(value); + } else { + int32_t fd = *(reinterpret_cast(data)); + int32_t len = *(reinterpret_cast(data)); + std::string name(reinterpret_cast(data), size); + pdata.WriteFileDescriptor(fd); + pdata.WriteInt32(len); + pdata.WriteString(name); + } + sptr unprepareDInputCallbackStub(new (std::nothrow) + MyUnprepareDInputCallbackStub()); + unprepareDInputCallbackStub->OnRemoteRequest(code, pdata, reply, option); +} + +class MyUnregisterDInputCallbackStub : public DistributedInput::UnregisterDInputCallbackStub { +public: + void OnResult(const std::string &devId, const std::string &dhId, const int32_t &status) override + { + return; + } +}; + +void UnregisterDInputCallbackStubFuzzTest(const uint8_t *data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(int32_t))) { + return; + } + MessageParcel pdata; + MessageParcel reply; + MessageOption option; + uint32_t code = *(reinterpret_cast(data)); + pdata.WriteInterfaceToken(DistributedInput::UnregisterDInputCallbackStub::GetDescriptor()); + if (code == (uint32_t)DistributedInput::IUnprepareDInputCallback::Message::RESULT) { + uint32_t tag = *(reinterpret_cast(data)); + std::string value(reinterpret_cast(data), size); + pdata.WriteUint32(tag); + pdata.WriteString(value); + } else { + int32_t fd = *(reinterpret_cast(data)); + int32_t len = *(reinterpret_cast(data)); + std::string name(reinterpret_cast(data), size); + pdata.WriteFileDescriptor(fd); + pdata.WriteInt32(len); + pdata.WriteString(name); + } + sptr unregisterDInputCallbackStub(new (std::nothrow) + MyUnregisterDInputCallbackStub()); + unregisterDInputCallbackStub->OnRemoteRequest(code, pdata, reply, option); } } // namespace DistributedHardware } // namespace OHOS /* Fuzzer entry point */ -extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { /* Run your code on data */ - OHOS::DistributedHardware::StartSessionFuzzTest(data, size); - OHOS::DistributedHardware::OnBytesReceivedFuzzTest(data, size); + OHOS::DistributedHardware::AddWhiteListInfosCallbackStubFuzzTest(data, size); + OHOS::DistributedHardware::DelWhiteListInfosCallbackStubFuzzTest(data, size); + OHOS::DistributedHardware::DistributedInputSinkStubFuzzTest(data, size); + OHOS::DistributedHardware::DistributedInputSourceStubFuzzTest(data, size); + OHOS::DistributedHardware::GetSinkScreenInfosCallbackStubFuzzTest(data, size); + OHOS::DistributedHardware::InputNodeListenerStubFuzzTest(data, size); + OHOS::DistributedHardware::PrepareDInputCallbackStubFuzzTest(data, size); + OHOS::DistributedHardware::RegisterDInputCallbackStubFuzzTest(data, size); + OHOS::DistributedHardware::RegisterSessionStateCallbackStubFuzzTest(data, size); + OHOS::DistributedHardware::SharingDhIdListenerStubFuzzTest(data, size); + OHOS::DistributedHardware::SimulationEventListenerStubFuzzTest(data, size); + OHOS::DistributedHardware::StartDInputCallbackStubFuzzTest(data, size); + OHOS::DistributedHardware::StartStopDInputsCallbackStubFuzzTest(data, size); + OHOS::DistributedHardware::StartStopResultCallbackStubFuzzTest(data, size); + OHOS::DistributedHardware::StopDInputCallbackStubFuzzTest(data, size); + OHOS::DistributedHardware::UnprepareDInputCallbackStubFuzzTest(data, size); + OHOS::DistributedHardware::UnregisterDInputCallbackStubFuzzTest(data, size); return 0; } \ No newline at end of file -- Gitee From d9a343eda5a847a5183468dc691cba9552d45841 Mon Sep 17 00:00:00 2001 From: torrizo Date: Mon, 15 Apr 2024 06:11:18 +0000 Subject: [PATCH 06/19] update bundle.json. Signed-off-by: torrizo --- bundle.json | 1 + 1 file changed, 1 insertion(+) diff --git a/bundle.json b/bundle.json index ebc2d1e..39a237c 100755 --- a/bundle.json +++ b/bundle.json @@ -93,6 +93,7 @@ "//foundation/distributedhardware/distributed_input/utils/test:test", "//foundation/distributedhardware/distributed_input/dfx_utils/test:test", "//foundation/distributedhardware/distributed_input/interfaces/ipc/test:test", + "//foundation/distributedhardware/distributed_input/interfaces/ipc/test/fuzztest:fuzztest", "//foundation/distributedhardware/distributed_input/inputdevicehandler/test:test", "//foundation/distributedhardware/distributed_input/services/state/test:test" ] -- Gitee From 06d5c1d8d41b1cc2c1cdfba9c406caa9414e2402 Mon Sep 17 00:00:00 2001 From: torrizo Date: Mon, 15 Apr 2024 06:20:07 +0000 Subject: [PATCH 07/19] update interfaces/ipc/test/fuzztest/BUILD.gn. Signed-off-by: torrizo --- interfaces/ipc/test/fuzztest/BUILD.gn | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/interfaces/ipc/test/fuzztest/BUILD.gn b/interfaces/ipc/test/fuzztest/BUILD.gn index 7b779fc..ffeef23 100644 --- a/interfaces/ipc/test/fuzztest/BUILD.gn +++ b/interfaces/ipc/test/fuzztest/BUILD.gn @@ -14,7 +14,5 @@ group("fuzztest") { testonly = true - deps = [ - "distributedinputstub_fuzzer:fuzztest", - ] -} \ No newline at end of file + deps = [ "distributedinputstub_fuzzer:fuzztest" ] +} -- Gitee From 8066001ff32937a5d25874e4b7dc75d961765212 Mon Sep 17 00:00:00 2001 From: torrizo Date: Mon, 15 Apr 2024 06:21:04 +0000 Subject: [PATCH 08/19] update interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/BUILD.gn. Signed-off-by: torrizo --- .../ipc/test/fuzztest/distributedinputstub_fuzzer/BUILD.gn | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/BUILD.gn b/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/BUILD.gn index c062ec8..71cb0d7 100644 --- a/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/BUILD.gn +++ b/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/BUILD.gn @@ -137,4 +137,4 @@ group("fuzztest") { deps = [ ":DistributedInputStubFuzzTest" ] } -############################################################################### \ No newline at end of file +############################################################################### -- Gitee From a841c59ddd5e3607524b71176e80fb740498e869 Mon Sep 17 00:00:00 2001 From: torrizo Date: Mon, 15 Apr 2024 06:25:10 +0000 Subject: [PATCH 09/19] update interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/BUILD.gn. Signed-off-by: torrizo --- .../ipc/test/fuzztest/distributedinputstub_fuzzer/BUILD.gn | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/BUILD.gn b/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/BUILD.gn index 71cb0d7..f1e432d 100644 --- a/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/BUILD.gn +++ b/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/BUILD.gn @@ -14,8 +14,7 @@ #####################hydra-fuzz################### import("//build/config/features.gni") import("//build/test.gni") -import( - "//foundation/distributedhardware/distributed_input/distributedinput.gni") +import("../../../distributedinput.gni") ##############################fuzztest########################################## ohos_fuzztest("DistributedInputStubFuzzTest") { -- Gitee From 74408387bbd180d3a588c848ebb80b70e7e4b453 Mon Sep 17 00:00:00 2001 From: torrizo Date: Mon, 15 Apr 2024 06:29:24 +0000 Subject: [PATCH 10/19] update interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/distributedinputstub_fuzzer.cpp. Signed-off-by: torrizo --- .../distributedinputstub_fuzzer.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/distributedinputstub_fuzzer.cpp b/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/distributedinputstub_fuzzer.cpp index ac1aa4c..97676f0 100644 --- a/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/distributedinputstub_fuzzer.cpp +++ b/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/distributedinputstub_fuzzer.cpp @@ -484,7 +484,7 @@ void InputNodeListenerStubFuzzTest(const uint8_t *data, size_t size) std::string value(reinterpret_cast(data), size); pdata.WriteUint32(tag); pdata.WriteString(value); - } else if(code == (uint32_t)DistributedInput::InputNodeListener::Message::RESULT_OFF) { + } else if (code == (uint32_t)DistributedInput::InputNodeListener::Message::RESULT_OFF) { int32_t fd = *(reinterpret_cast(data)); int32_t len = *(reinterpret_cast(data)); std::string name(reinterpret_cast(data), size); @@ -641,7 +641,7 @@ void SharingDhIdListenerStubFuzzTest(const uint8_t *data, size_t size) std::string value(reinterpret_cast(data), size); pdata.WriteUint32(tag); pdata.WriteString(value); - } else if(code == (uint32_t)DistributedInput::ISharingDhIdListener::Message::NO_SHARING) { + } else if (code == (uint32_t)DistributedInput::ISharingDhIdListener::Message::NO_SHARING) { int32_t fd = *(reinterpret_cast(data)); int32_t len = *(reinterpret_cast(data)); std::string name(reinterpret_cast(data), size); -- Gitee From 3ae015c0337f0d9ac33dbe2d246d0d1ccc5d0160 Mon Sep 17 00:00:00 2001 From: torrizo Date: Mon, 15 Apr 2024 06:29:48 +0000 Subject: [PATCH 11/19] update interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/distributedinputstub_fuzzer.h. Signed-off-by: torrizo --- .../distributedinputstub_fuzzer/distributedinputstub_fuzzer.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/distributedinputstub_fuzzer.h b/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/distributedinputstub_fuzzer.h index a4fbdbd..17fa36c 100644 --- a/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/distributedinputstub_fuzzer.h +++ b/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/distributedinputstub_fuzzer.h @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef TEST_AVTRANSCALLBACKNOTIFY_FUZZER_H -#define TEST_AVTRANSCALLBACKNOTIFY_FUZZER_H +#ifndef DISTRIBUTEDINPUTSTUB_FUZZER_H +#define DISTRIBUTEDINPUTSTUB_FUZZER_H #define FUZZ_PROJECT_NAME "distributedinputstub_fuzzer.cpp" -- Gitee From 6240500170c81f05d6aa9e0f53dc9fdbc110d8f7 Mon Sep 17 00:00:00 2001 From: torrizo Date: Mon, 15 Apr 2024 06:38:29 +0000 Subject: [PATCH 12/19] update interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/BUILD.gn. Signed-off-by: torrizo --- .../ipc/test/fuzztest/distributedinputstub_fuzzer/BUILD.gn | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/BUILD.gn b/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/BUILD.gn index f1e432d..48ae1bc 100644 --- a/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/BUILD.gn +++ b/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/BUILD.gn @@ -1,4 +1,4 @@ -# Copyright (c) 2021-2024 Huawei Device Co., Ltd. +# Copyright (c) 2024 Huawei Device Co., Ltd. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at -- Gitee From e92abcc239dcc4b710d9518ab13fd85509685a29 Mon Sep 17 00:00:00 2001 From: torrizo Date: Mon, 15 Apr 2024 06:39:30 +0000 Subject: [PATCH 13/19] update interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/corpus/init. Signed-off-by: torrizo --- .../ipc/test/fuzztest/distributedinputstub_fuzzer/corpus/init | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/corpus/init b/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/corpus/init index c49c21a..7e96755 100644 --- a/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/corpus/init +++ b/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/corpus/init @@ -1,4 +1,4 @@ -# Copyright (c) 2022 Huawei Device Co., Ltd. +# Copyright (c) 2024 Huawei Device Co., Ltd. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at -- Gitee From 07837ba36e58848d02dc463c84c14f30435b29ab Mon Sep 17 00:00:00 2001 From: torrizo Date: Mon, 15 Apr 2024 06:42:21 +0000 Subject: [PATCH 14/19] update interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/distributedinputstub_fuzzer.cpp. Signed-off-by: torrizo --- .../distributedinputstub_fuzzer/distributedinputstub_fuzzer.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/distributedinputstub_fuzzer.cpp b/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/distributedinputstub_fuzzer.cpp index 97676f0..50264ef 100644 --- a/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/distributedinputstub_fuzzer.cpp +++ b/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/distributedinputstub_fuzzer.cpp @@ -798,7 +798,7 @@ void StartStopResultCallbackStubFuzzTest(const uint8_t *data, size_t size) std::string value(reinterpret_cast(data), size); pdata.WriteUint32(tag); pdata.WriteString(value); - } else if(code == (uint32_t)DistributedInput::IStartStopResultCallback::Message::RESULT_STOP) { + } else if (code == (uint32_t)DistributedInput::IStartStopResultCallback::Message::RESULT_STOP) { int32_t fd = *(reinterpret_cast(data)); int32_t len = *(reinterpret_cast(data)); std::string name(reinterpret_cast(data), size); -- Gitee From 756bfce2a8be15065d97781c8bcf89557a0bb078 Mon Sep 17 00:00:00 2001 From: torrizo Date: Mon, 15 Apr 2024 06:44:14 +0000 Subject: [PATCH 15/19] update interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/project.xml. Signed-off-by: torrizo --- .../ipc/test/fuzztest/distributedinputstub_fuzzer/project.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/project.xml b/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/project.xml index 6e8ad2c..7133b2b 100644 --- a/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/project.xml +++ b/interfaces/ipc/test/fuzztest/distributedinputstub_fuzzer/project.xml @@ -1,5 +1,5 @@ -