1 /*
2 * Copyright (c) 2022 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 "clienttransudpmanager_fuzzer.h"
17
18 #include <securec.h>
19
20 #include "client_trans_udp_manager.h"
21 #include "fuzz_data_generator.h"
22 #include "session.h"
23 #include "softbus_adapter_mem.h"
24
25 #define STR_LEN 100000
26 #define TEST_TMP_STR_LEN 50
27 #define TEST_TMP_STR "testtmpStr"
28 namespace OHOS {
TransOnUdpChannelOpenedTest(const uint8_t * data,size_t size)29 void TransOnUdpChannelOpenedTest(const uint8_t* data, size_t size)
30 {
31 if (data == nullptr || size < sizeof(int32_t)) {
32 return;
33 }
34 ChannelInfo channel = {0};
35 channel.channelType = CHANNEL_TYPE_UDP;
36 channel.businessType = BUSINESS_TYPE_STREAM;
37 DataGenerator::Write(data, size);
38 int32_t udpPort = 0;
39 GenerateInt32(udpPort);
40 TransOnUdpChannelOpened((char *)data, &channel, &udpPort);
41 DataGenerator::Clear();
42 }
43
TransOnUdpChannelOpenFailedTest(const uint8_t * data,size_t size)44 void TransOnUdpChannelOpenFailedTest(const uint8_t* data, size_t size)
45 {
46 if (data == nullptr || size < sizeof(int32_t)) {
47 return;
48 }
49 DataGenerator::Write(data, size);
50 int32_t channelId = 0;
51 int32_t errCode = 0;
52 GenerateInt32(channelId);
53 GenerateInt32(errCode);
54 TransOnUdpChannelOpenFailed(channelId, errCode);
55 DataGenerator::Clear();
56 }
57
TransOnUdpChannelClosedTest(const uint8_t * data,size_t size)58 void TransOnUdpChannelClosedTest(const uint8_t* data, size_t size)
59 {
60 if (data == nullptr || size < sizeof(int32_t)) {
61 return;
62 }
63 DataGenerator::Write(data, size);
64 int32_t channelId = 0;
65 GenerateInt32(channelId);
66 TransOnUdpChannelClosed(channelId, SHUTDOWN_REASON_UNKNOWN);
67 DataGenerator::Clear();
68 }
69
TransOnUdpChannelQosEventTest(const uint8_t * data,size_t size)70 void TransOnUdpChannelQosEventTest(const uint8_t* data, size_t size)
71 {
72 if (data == nullptr || size < sizeof(int32_t)) {
73 return;
74 }
75 DataGenerator::Write(data, size);
76 int32_t channelId = 0;
77 int32_t eventId = 0;
78 int32_t tvCount = 0;
79 GenerateInt32(channelId);
80 GenerateInt32(eventId);
81 GenerateInt32(tvCount);
82 QosTv tvList;
83 TransOnUdpChannelQosEvent(channelId, eventId, tvCount, &tvList);
84 DataGenerator::Clear();
85 }
86
ClientTransCloseUdpChannelTest(const uint8_t * data,size_t size)87 void ClientTransCloseUdpChannelTest(const uint8_t* data, size_t size)
88 {
89 if (data == nullptr || size < sizeof(int32_t)) {
90 return;
91 }
92 DataGenerator::Write(data, size);
93 int32_t channelId = 0;
94 GenerateInt32(channelId);
95 ClientTransCloseUdpChannel(channelId, SHUTDOWN_REASON_UNKNOWN);
96 DataGenerator::Clear();
97 }
98
TransUdpChannelSendStreamTest(const uint8_t * data,size_t size)99 void TransUdpChannelSendStreamTest(const uint8_t* data, size_t size)
100 {
101 if (data == nullptr || size < sizeof(int64_t)) {
102 return;
103 }
104 uint8_t *ptr = static_cast<uint8_t *>(SoftBusCalloc(size + 1));
105 if (ptr == nullptr) {
106 return;
107 }
108 if (memcpy_s(ptr, size, data, size) != EOK) {
109 SoftBusFree(ptr);
110 return;
111 }
112 DataGenerator::Write(data, size);
113 int32_t channelId = 0;
114 GenerateInt32(channelId);
115 StreamData streamdata = {
116 .buf = const_cast<char *>(reinterpret_cast<const char *>(ptr)),
117 .bufLen = size,
118 };
119 StreamData ext = {
120 .buf = const_cast<char *>(reinterpret_cast<const char *>(ptr)),
121 .bufLen = size,
122 };
123 TV tv = { 0 };
124 GenerateInt32(tv.type);
125 GenerateInt64(tv.value);
126 StreamFrameInfo param = {
127 .tvCount = 1,
128 .tvList = &tv,
129 };
130 GenerateInt32(param.frameType);
131 GenerateInt64(param.timeStamp);
132 GenerateInt32(param.seqNum);
133 GenerateInt32(param.seqSubNum);
134 GenerateInt32(param.level);
135 GenerateInt32(param.bitMap);
136 TransUdpChannelSendStream(channelId, &streamdata, &ext, ¶m);
137 SoftBusFree(ptr);
138 DataGenerator::Clear();
139 }
140
TransUdpChannelSendFileTest(const uint8_t * data,size_t size)141 void TransUdpChannelSendFileTest(const uint8_t* data, size_t size)
142 {
143 if (data == nullptr || size < sizeof(int32_t)) {
144 return;
145 }
146 const char *sfileList[] = {
147 "/data/big.tar",
148 "/data/richu.jpg",
149 "/data/richu-002.jpg",
150 "/data/richu-003.jpg",
151 };
152 DataGenerator::Write(data, size);
153 int32_t channelId = 0;
154 int32_t fileCnt = 0;
155 GenerateInt32(channelId);
156 GenerateInt32(fileCnt);
157 TransUdpChannelSendFile(channelId, sfileList, nullptr, fileCnt);
158 DataGenerator::Clear();
159 }
160
TransGetUdpChannelByFileIdTest(const uint8_t * data,size_t size)161 void TransGetUdpChannelByFileIdTest(const uint8_t* data, size_t size)
162 {
163 if (data == nullptr || size < sizeof(int32_t)) {
164 return;
165 }
166 DataGenerator::Write(data, size);
167 int32_t dfileId = 0;
168 GenerateInt32(dfileId);
169 UdpChannel udpChannel;
170 TransGetUdpChannelByFileId(dfileId, &udpChannel);
171 DataGenerator::Clear();
172 }
173
TransUdpDeleteFileListenerlTest(const uint8_t * data,size_t size)174 void TransUdpDeleteFileListenerlTest(const uint8_t* data, size_t size)
175 {
176 if (data == nullptr || size < SESSION_NAME_SIZE_MAX) {
177 return;
178 }
179 char tmp[SESSION_NAME_SIZE_MAX + 1] = {0};
180 if (memcpy_s(tmp, sizeof(tmp) - 1, data, sizeof(tmp) - 1) != EOK) {
181 return;
182 }
183 TransUdpDeleteFileListener(tmp);
184 }
185 } // namespace OHOS
186
187 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)188 extern "C" int32_t LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
189 {
190 /* Run your code on data */
191 OHOS::TransOnUdpChannelOpenedTest(data, size);
192 OHOS::TransOnUdpChannelOpenFailedTest(data, size);
193 OHOS::TransOnUdpChannelClosedTest(data, size);
194 OHOS::TransOnUdpChannelQosEventTest(data, size);
195 OHOS::ClientTransCloseUdpChannelTest(data, size);
196 OHOS::TransUdpChannelSendStreamTest(data, size);
197 OHOS::TransUdpChannelSendFileTest(data, size);
198 OHOS::TransGetUdpChannelByFileIdTest(data, size);
199 OHOS::TransUdpDeleteFileListenerlTest(data, size);
200 return 0;
201 }
202
