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 "dschedtransportsoftbusadapter_fuzzer.h"
17
18 #include <fuzzer/FuzzedDataProvider.h>
19
20 #include "dsched_continue_manager.h"
21 #include "dsched_data_buffer.h"
22 #include "dsched_transport_softbus_adapter.h"
23 #include "idata_listener.h"
24
25 namespace OHOS {
26 namespace DistributedSchedule {
27 namespace {
28 constexpr uint32_t MAX_BUFFER_SIZE = 80 * 1024 * 1024;
29 }
30
FuzzOnBind(const uint8_t * data,size_t size)31 void FuzzOnBind(const uint8_t* data, size_t size)
32 {
33 if ((data == nullptr) || (size < sizeof(size_t))) {
34 return;
35 }
36 FuzzedDataProvider fdp(data, size);
37 int32_t sessionId = fdp.ConsumeIntegral<int32_t>();
38 std::string peerDeviceId = fdp.ConsumeRandomLengthString();
39 DSchedTransportSoftbusAdapter dschedTransportSoftbusAdapter;
40 dschedTransportSoftbusAdapter.OnBind(sessionId, peerDeviceId);
41 }
42
FuzzOnShutdown(const uint8_t * data,size_t size)43 void FuzzOnShutdown(const uint8_t* data, size_t size)
44 {
45 if ((data == nullptr) || (size < sizeof(size_t))) {
46 return;
47 }
48 FuzzedDataProvider fdp(data, size);
49 bool isSelfcalled = fdp.ConsumeBool();
50 int32_t sessionId = fdp.ConsumeIntegral<int32_t>();
51 DSchedTransportSoftbusAdapter dschedTransportSoftbusAdapter;
52 dschedTransportSoftbusAdapter.OnShutdown(sessionId, isSelfcalled);
53 }
54
FuzzOnBytes(const uint8_t * data,size_t size)55 void FuzzOnBytes(const uint8_t* data, size_t size)
56 {
57 if ((data == nullptr) || (size < sizeof(size_t))) {
58 return;
59 }
60 const void* newdata = reinterpret_cast<const void*>(data);
61 FuzzedDataProvider fdp(data, size);
62 int32_t sessionId = fdp.ConsumeIntegral<int32_t>();
63 int32_t dataLen = fdp.ConsumeIntegral<int32_t>();
64 DSchedTransportSoftbusAdapter dschedTransportSoftbusAdapter;
65 dschedTransportSoftbusAdapter.OnBytes(sessionId, newdata, dataLen);
66 }
67
FuzzConnectDevice(const uint8_t * data,size_t size)68 void FuzzConnectDevice(const uint8_t* data, size_t size)
69 {
70 if ((data == nullptr) || (size < sizeof(size_t)) || size >= MAX_BUFFER_SIZE) {
71 return;
72 }
73 FuzzedDataProvider fdp(data, size);
74 int32_t sessionId = fdp.ConsumeIntegral<int32_t>();
75 int32_t dataType = fdp.ConsumeIntegral<int32_t>();
76 std::string peerDeviceId = fdp.ConsumeRandomLengthString();
77
78 DSchedTransportSoftbusAdapter dschedTransportSoftbusAdapter;
79 dschedTransportSoftbusAdapter.ConnectDevice(peerDeviceId, sessionId);
80 std::shared_ptr<DSchedDataBuffer> dataBuffer = std::make_shared<DSchedDataBuffer>(size);
81 dschedTransportSoftbusAdapter.SendData(sessionId, dataType, dataBuffer);
82 dschedTransportSoftbusAdapter.SendBytesBySoftbus(sessionId, dataBuffer);
83 dschedTransportSoftbusAdapter.InitChannel();
84 dschedTransportSoftbusAdapter.CreateServerSocket();
85 dschedTransportSoftbusAdapter.CreateClientSocket(peerDeviceId);
86 bool isServer = sessionId % 2;
87 dschedTransportSoftbusAdapter.CreateSessionRecord(sessionId, peerDeviceId, isServer, SERVICE_TYPE_CONTINUE);
88 dschedTransportSoftbusAdapter.AddNewPeerSession(peerDeviceId, sessionId, SERVICE_TYPE_CONTINUE);
89 dschedTransportSoftbusAdapter.ShutdownSession(peerDeviceId, sessionId);
90 bool isSelfCalled = sessionId % 2;
91 dschedTransportSoftbusAdapter.NotifyListenersSessionShutdown(sessionId, isSelfCalled);
92 dschedTransportSoftbusAdapter.ReleaseChannel();
93 }
94
FuzzDisconnectDevice(const uint8_t * data,size_t size)95 void FuzzDisconnectDevice(const uint8_t* data, size_t size)
96 {
97 if ((data == nullptr) || (size < sizeof(size_t))) {
98 return;
99 }
100 FuzzedDataProvider fdp(data, size);
101 std::string peerDeviceId = fdp.ConsumeRandomLengthString();
102 DSchedTransportSoftbusAdapter dschedTransportSoftbusAdapter;
103 dschedTransportSoftbusAdapter.DisconnectDevice(peerDeviceId);
104 }
105
106
FuzzOnDataReady(const uint8_t * data,size_t size)107 void FuzzOnDataReady(const uint8_t* data, size_t size)
108 {
109 if ((data == nullptr) || (size < sizeof(size_t)) || size >= MAX_BUFFER_SIZE) {
110 return;
111 }
112 FuzzedDataProvider fdp(data, size);
113 int32_t sessionId = fdp.ConsumeIntegral<int32_t>();
114 uint32_t dataType = fdp.ConsumeIntegral<uint32_t>();
115 std::shared_ptr<DSchedDataBuffer> dataBuffer = std::make_shared<DSchedDataBuffer>(size);
116 DSchedTransportSoftbusAdapter dschedTransportSoftbusAdapter;
117 dschedTransportSoftbusAdapter.OnDataReady(sessionId, dataBuffer, dataType);
118 }
119
FuzzRegisterListener(const uint8_t * data,size_t size)120 void FuzzRegisterListener(const uint8_t* data, size_t size)
121 {
122 if ((data == nullptr) || (size < sizeof(size_t))) {
123 return;
124 }
125 FuzzedDataProvider fdp(data, size);
126 int32_t serviceType = fdp.ConsumeIntegral<int32_t>();
127 std::shared_ptr<DSchedContinueManager::SoftbusListener> listener =
128 std::make_shared<DSchedContinueManager::SoftbusListener>();
129 DSchedTransportSoftbusAdapter dschedTransportSoftbusAdapter;
130 dschedTransportSoftbusAdapter.RegisterListener(serviceType, listener);
131 }
132
FuzzUnregisterListener(const uint8_t * data,size_t size)133 void FuzzUnregisterListener(const uint8_t* data, size_t size)
134 {
135 if ((data == nullptr) || (size < sizeof(size_t))) {
136 return;
137 }
138 FuzzedDataProvider fdp(data, size);
139 int32_t serviceType = fdp.ConsumeIntegral<int32_t>();
140 std::shared_ptr<DSchedContinueManager::SoftbusListener> listener =
141 std::make_shared<DSchedContinueManager::SoftbusListener>();
142 DSchedTransportSoftbusAdapter dschedTransportSoftbusAdapter;
143 dschedTransportSoftbusAdapter.UnregisterListener(serviceType, listener);
144 }
145
FuzzSetCallingTokenId(const uint8_t * data,size_t size)146 void FuzzSetCallingTokenId(const uint8_t* data, size_t size)
147 {
148 if ((data == nullptr) || (size < sizeof(size_t))) {
149 return;
150 }
151 FuzzedDataProvider fdp(data, size);
152 int32_t callingTokenId = fdp.ConsumeIntegral<int32_t>();
153 DSchedTransportSoftbusAdapter dschedTransportSoftbusAdapter;
154 dschedTransportSoftbusAdapter.SetCallingTokenId(callingTokenId);
155 }
156
FuzzGetSessionIdByDeviceId(const uint8_t * data,size_t size)157 void FuzzGetSessionIdByDeviceId(const uint8_t* data, size_t size)
158 {
159 if ((data == nullptr) || (size < sizeof(size_t))) {
160 return;
161 }
162 FuzzedDataProvider fdp(data, size);
163 int32_t sessionId = fdp.ConsumeIntegral<int32_t>();
164 std::string peerDeviceId = fdp.ConsumeRandomLengthString();
165 DSchedTransportSoftbusAdapter dschedTransportSoftbusAdapter;
166 dschedTransportSoftbusAdapter.GetSessionIdByDeviceId(peerDeviceId, sessionId);
167 }
168 }
169 }
170
171 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)172 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
173 {
174 OHOS::DistributedSchedule::FuzzOnBind(data, size);
175 OHOS::DistributedSchedule::FuzzOnShutdown(data, size);
176 OHOS::DistributedSchedule::FuzzOnBytes(data, size);
177 OHOS::DistributedSchedule::FuzzConnectDevice(data, size);
178 OHOS::DistributedSchedule::FuzzDisconnectDevice(data, size);
179 OHOS::DistributedSchedule::FuzzOnDataReady(data, size);
180 OHOS::DistributedSchedule::FuzzRegisterListener(data, size);
181 OHOS::DistributedSchedule::FuzzUnregisterListener(data, size);
182 OHOS::DistributedSchedule::FuzzSetCallingTokenId(data, size);
183 OHOS::DistributedSchedule::FuzzGetSessionIdByDeviceId(data, size);
184 return 0;
185 }
186