1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "softbusclientstub_fuzzer.h"
17
18 #include <cstddef>
19 #include <cstdint>
20 #include "softbus_client_stub.h"
21 #include "message_parcel.h"
22 #include "securec.h"
23
24 namespace OHOS {
25 constexpr size_t FOO_MAX_LEN = 1024;
26 constexpr size_t U32_AT_SIZE = 4;
27
28 enum SoftBusFuncId {
29 CLIENT_ON_CHANNEL_OPENED = 256,
30 CLIENT_ON_CHANNEL_OPENFAILED,
31 CLIENT_ON_CHANNEL_LINKDOWN,
32 CLIENT_ON_CHANNEL_CLOSED,
33 CLIENT_ON_CHANNEL_MSGRECEIVED,
34 CLIENT_ON_CHANNEL_QOSEVENT,
35
36 CLIENT_DISCOVERY_SUCC,
37 CLIENT_DISCOVERY_FAIL,
38 CLIENT_DISCOVERY_DEVICE_FOUND,
39 CLIENT_PUBLISH_SUCC,
40 CLIENT_PUBLISH_FAIL,
41
42 CLIENT_ON_JOIN_RESULT,
43 CLIENT_ON_JOIN_METANODE_RESULT,
44 CLIENT_ON_LEAVE_RESULT,
45 CLIENT_ON_LEAVE_METANODE_RESULT,
46 CLIENT_ON_NODE_ONLINE_STATE_CHANGED,
47 CLIENT_ON_NODE_BASIC_INFO_CHANGED,
48 CLIENT_ON_TIME_SYNC_RESULT,
49 CLIENT_ON_PUBLISH_LNN_RESULT,
50 CLIENT_ON_REFRESH_LNN_RESULT,
51 CLIENT_ON_REFRESH_DEVICE_FOUND,
52 CLIENT_ON_PERMISSION_CHANGE,
53 };
54
55 const std::u16string SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN = u"OHOS.ISoftBusClient";
56
OnChannelOpenedInnerTest(const uint8_t * data,size_t size)57 bool OnChannelOpenedInnerTest(const uint8_t* data, size_t size)
58 {
59 (void)size;
60 int32_t intNum = *(reinterpret_cast<const int32_t*>(data));
61 constexpr size_t len = 4;
62 MessageParcel datas;
63 bool boolNum = true;
64 const char* test = "test";
65 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
66 datas.WriteInt32(intNum);
67 datas.WriteBool(boolNum);
68 datas.WriteRawData(test, len);
69 datas.RewindRead(0);
70 MessageParcel reply;
71 MessageOption option;
72 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
73 if (softBusClientStub == nullptr) {
74 return false;
75 }
76 softBusClientStub->OnRemoteRequest(CLIENT_ON_CHANNEL_OPENED, datas, reply, option);
77 return true;
78 }
79
OnChannelOpenFailedInnerTest(const uint8_t * data,size_t size)80 bool OnChannelOpenFailedInnerTest(const uint8_t* data, size_t size)
81 {
82 (void)size;
83 int32_t intNum = *(reinterpret_cast<const int32_t*>(data));
84 constexpr int32_t channelType = 4;
85 constexpr int32_t errCode = 5;
86 MessageParcel datas;
87 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
88 datas.WriteInt32(intNum);
89 datas.WriteInt32(channelType);
90 datas.WriteInt32(errCode);
91 datas.RewindRead(0);
92 MessageParcel reply;
93 MessageOption option;
94 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
95 if (softBusClientStub == nullptr) {
96 return false;
97 }
98 softBusClientStub->OnRemoteRequest(CLIENT_ON_CHANNEL_OPENFAILED, datas, reply, option);
99 return true;
100 }
101
OnChannelLinkDownInnerTest(const uint8_t * data,size_t size)102 bool OnChannelLinkDownInnerTest(const uint8_t* data, size_t size)
103 {
104 constexpr int32_t intNum = 4;
105 MessageParcel datas;
106 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
107 datas.WriteBuffer(data, size);
108 datas.WriteInt32(intNum);
109 datas.RewindRead(0);
110 MessageParcel reply;
111 MessageOption option;
112 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
113 if (softBusClientStub == nullptr) {
114 return false;
115 }
116 softBusClientStub->OnRemoteRequest(CLIENT_ON_CHANNEL_LINKDOWN, datas, reply, option);
117 return true;
118 }
119
OnChannelClosedInnerTest(const uint8_t * data,size_t size)120 bool OnChannelClosedInnerTest(const uint8_t* data, size_t size)
121 {
122 (void)size;
123 int32_t intNum = *(reinterpret_cast<const int32_t*>(data));
124 constexpr int32_t channelType = 4;
125 MessageParcel datas;
126 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
127 datas.WriteInt32(intNum);
128 datas.WriteInt32(channelType);
129 datas.RewindRead(0);
130 MessageParcel reply;
131 MessageOption option;
132 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
133 if (softBusClientStub == nullptr) {
134 return false;
135 }
136 softBusClientStub->OnRemoteRequest(CLIENT_ON_CHANNEL_CLOSED, datas, reply, option);
137 return true;
138 }
139
OnChannelMsgReceivedInnerTest(const uint8_t * data,size_t size)140 bool OnChannelMsgReceivedInnerTest(const uint8_t* data, size_t size)
141 {
142 (void)size;
143 constexpr int32_t channelId = 4;
144 constexpr int32_t channelType = 2;
145 constexpr uint32_t len = 18;
146 constexpr int32_t type = 2;
147 constexpr size_t lenStr = 4;
148 const char* test = "test";
149 MessageParcel datas;
150 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
151 datas.WriteInt32(channelId);
152 datas.WriteInt32(channelType);
153 datas.WriteUint32(len);
154 datas.WriteRawData(test, lenStr);
155 datas.WriteBuffer(data, size);
156 datas.WriteInt32(type);
157 datas.RewindRead(0);
158 MessageParcel reply;
159 MessageOption option;
160 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
161 if (softBusClientStub == nullptr) {
162 return false;
163 }
164 softBusClientStub->OnRemoteRequest(CLIENT_ON_CHANNEL_MSGRECEIVED, datas, reply, option);
165 return true;
166 }
167
OnChannelQosEventInnerTest(const uint8_t * data,size_t size)168 bool OnChannelQosEventInnerTest(const uint8_t* data, size_t size)
169 {
170 int32_t channelId = *(reinterpret_cast<const int32_t*>(data));
171 constexpr int32_t channelType = 3;
172 constexpr int32_t eventId = 2;
173 constexpr int32_t tvCount = 1;
174 constexpr size_t len = 4;
175 const char* test = "test";
176 MessageParcel datas;
177 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
178 datas.WriteInt32(channelId);
179 datas.WriteInt32(channelType);
180 datas.WriteInt32(eventId);
181 datas.WriteRawData(test, len);
182 datas.WriteInt32(tvCount);
183 datas.RewindRead(0);
184 MessageParcel reply;
185 MessageOption option;
186 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
187 if (softBusClientStub == nullptr) {
188 return false;
189 }
190 softBusClientStub->OnRemoteRequest(CLIENT_ON_CHANNEL_QOSEVENT, datas, reply, option);
191 return true;
192 }
193
OnDeviceFoundInnerTest(const uint8_t * data,size_t size)194 bool OnDeviceFoundInnerTest(const uint8_t* data, size_t size)
195 {
196 MessageParcel datas;
197 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
198 datas.WriteBuffer(data, size);
199 datas.RewindRead(0);
200 MessageParcel reply;
201 MessageOption option;
202 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
203 if (softBusClientStub == nullptr) {
204 return false;
205 }
206 softBusClientStub->OnRemoteRequest(CLIENT_DISCOVERY_DEVICE_FOUND, datas, reply, option);
207 return true;
208 }
209
OnJoinLNNResultInnerTest(const uint8_t * data,size_t size)210 bool OnJoinLNNResultInnerTest(const uint8_t* data, size_t size)
211 {
212 constexpr uint32_t addrTypeLen = 10;
213 constexpr int32_t retCode = 2;
214 const char* test = "test";
215 constexpr size_t len = 4;
216 MessageParcel datas;
217 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
218 datas.WriteUint32(addrTypeLen);
219 datas.WriteInt32(retCode);
220 datas.WriteRawData(test, len);
221 datas.WriteBuffer(data, size);
222 datas.RewindRead(0);
223 MessageParcel reply;
224 MessageOption option;
225 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
226 if (softBusClientStub == nullptr) {
227 return false;
228 }
229 softBusClientStub->OnRemoteRequest(CLIENT_ON_JOIN_RESULT, datas, reply, option);
230 return true;
231 }
232
OnJoinMetaNodeResultInnerTest(const uint8_t * data,size_t size)233 bool OnJoinMetaNodeResultInnerTest(const uint8_t* data, size_t size)
234 {
235 constexpr uint32_t addrTypeLen = 12;
236 constexpr int32_t retCode = 2;
237 const char* test = "test";
238 constexpr size_t len = 4;
239 MessageParcel datas;
240 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
241 datas.WriteUint32(addrTypeLen);
242 datas.WriteInt32(retCode);
243 datas.WriteRawData(test, len);
244 datas.WriteBuffer(data, size);
245 datas.RewindRead(0);
246 MessageParcel reply;
247 MessageOption option;
248 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
249 if (softBusClientStub == nullptr) {
250 return false;
251 }
252 softBusClientStub->OnRemoteRequest(CLIENT_ON_JOIN_METANODE_RESULT, datas, reply, option);
253 return true;
254 }
255
OnLeaveLNNResultInnerTest(const uint8_t * data,size_t size)256 bool OnLeaveLNNResultInnerTest(const uint8_t* data, size_t size)
257 {
258 constexpr int32_t intNum = 2;
259 MessageParcel datas;
260 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
261 datas.WriteBuffer(data, size);
262 datas.WriteInt32(intNum);
263 datas.RewindRead(0);
264 MessageParcel reply;
265 MessageOption option;
266 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
267 if (softBusClientStub == nullptr) {
268 return false;
269 }
270 softBusClientStub->OnRemoteRequest(CLIENT_ON_LEAVE_RESULT, datas, reply, option);
271 return true;
272 }
273
OnLeaveMetaNodeResultInnerTest(const uint8_t * data,size_t size)274 bool OnLeaveMetaNodeResultInnerTest(const uint8_t* data, size_t size)
275 {
276 constexpr int32_t intNum = 2;
277 MessageParcel datas;
278 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
279 datas.WriteBuffer(data, size);
280 datas.WriteInt32(intNum);
281 datas.RewindRead(0);
282 MessageParcel reply;
283 MessageOption option;
284 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
285 if (softBusClientStub == nullptr) {
286 return false;
287 }
288 softBusClientStub->OnRemoteRequest(CLIENT_ON_LEAVE_METANODE_RESULT, datas, reply, option);
289 return true;
290 }
291
OnNodeOnlineStateChangedInnerTest(const uint8_t * data,size_t size)292 bool OnNodeOnlineStateChangedInnerTest(const uint8_t* data, size_t size)
293 {
294 constexpr uint32_t infoTypeLen = 10;
295 bool boolNum = true;
296 const char* test = "test";
297 constexpr size_t len = 4;
298 MessageParcel datas;
299 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
300 datas.WriteBuffer(data, size);
301 datas.WriteBool(boolNum);
302 datas.WriteUint32(infoTypeLen);
303 datas.WriteRawData(test, len);
304 datas.RewindRead(0);
305 MessageParcel reply;
306 MessageOption option;
307 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
308 if (softBusClientStub == nullptr) {
309 return false;
310 }
311 softBusClientStub->OnRemoteRequest(CLIENT_ON_NODE_ONLINE_STATE_CHANGED, datas, reply, option);
312 return true;
313 }
314
OnNodeBasicInfoChangedInnerTest(const uint8_t * data,size_t size)315 bool OnNodeBasicInfoChangedInnerTest(const uint8_t* data, size_t size)
316 {
317 constexpr int32_t type = 2;
318 constexpr uint32_t infoTypeLen = 10;
319 const char* test = "test";
320 constexpr size_t len = 4;
321 MessageParcel datas;
322 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
323 datas.WriteBuffer(data, size);
324 datas.WriteRawData(test, len);
325 datas.WriteInt32(type);
326 datas.WriteUint32(infoTypeLen);
327 datas.RewindRead(0);
328 MessageParcel reply;
329 MessageOption option;
330 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
331 if (softBusClientStub == nullptr) {
332 return false;
333 }
334 softBusClientStub->OnRemoteRequest(CLIENT_ON_NODE_BASIC_INFO_CHANGED, datas, reply, option);
335 return true;
336 }
337
OnTimeSyncResultInnerTest(const uint8_t * data,size_t size)338 bool OnTimeSyncResultInnerTest(const uint8_t* data, size_t size)
339 {
340 constexpr uint32_t infoTypeLen = 10;
341 int32_t retCode = *(reinterpret_cast<const char*>(data));
342 const char* test = "test";
343 constexpr size_t len = 4;
344 MessageParcel datas;
345 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
346 datas.WriteInt32(retCode);
347 datas.WriteUint32(infoTypeLen);
348 datas.WriteRawData(test, len);
349 datas.RewindRead(0);
350 MessageParcel reply;
351 MessageOption option;
352 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
353 if (softBusClientStub == nullptr) {
354 return false;
355 }
356 softBusClientStub->OnRemoteRequest(CLIENT_ON_TIME_SYNC_RESULT, datas, reply, option);
357 return true;
358 }
359
OnPublishLNNResultInnerTest(const uint8_t * data,size_t size)360 bool OnPublishLNNResultInnerTest(const uint8_t* data, size_t size)
361 {
362 (void)size;
363 int32_t intNum = *(reinterpret_cast<const int32_t*>(data));
364 constexpr int32_t reason = 2;
365 MessageParcel datas;
366 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
367 datas.WriteInt32(intNum);
368 datas.WriteInt32(reason);
369 datas.RewindRead(0);
370 MessageParcel reply;
371 MessageOption option;
372 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
373 if (softBusClientStub == nullptr) {
374 return false;
375 }
376 softBusClientStub->OnRemoteRequest(CLIENT_ON_PUBLISH_LNN_RESULT, datas, reply, option);
377 return true;
378 }
379
OnRefreshLNNResultInnerTest(const uint8_t * data,size_t size)380 bool OnRefreshLNNResultInnerTest(const uint8_t* data, size_t size)
381 {
382 (void)size;
383 int32_t intNum = *(reinterpret_cast<const int32_t*>(data));
384 constexpr int32_t reason = 8;
385 MessageParcel datas;
386 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
387 datas.WriteInt32(intNum);
388 datas.WriteInt32(reason);
389 datas.RewindRead(0);
390 MessageParcel reply;
391 MessageOption option;
392 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
393 if (softBusClientStub == nullptr) {
394 return false;
395 }
396 softBusClientStub->OnRemoteRequest(CLIENT_ON_REFRESH_LNN_RESULT, datas, reply, option);
397 return true;
398 }
399
OnRefreshDeviceFoundInnerTest(const uint8_t * data,size_t size)400 bool OnRefreshDeviceFoundInnerTest(const uint8_t* data, size_t size)
401 {
402 uint32_t deviceLen = *(reinterpret_cast<const int32_t*>(data));
403 const char* test = "test";
404 MessageParcel datas;
405 constexpr size_t len = 4;
406 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
407 datas.WriteUint32(deviceLen);
408 datas.WriteRawData(test, len);
409 datas.RewindRead(0);
410 MessageParcel reply;
411 MessageOption option;
412 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
413 if (softBusClientStub == nullptr) {
414 return false;
415 }
416 softBusClientStub->OnRemoteRequest(CLIENT_ON_REFRESH_DEVICE_FOUND, datas, reply, option);
417 return true;
418 }
419
OnClientPermissonChangeInnerTest(const uint8_t * data,size_t size)420 bool OnClientPermissonChangeInnerTest(const uint8_t* data, size_t size)
421 {
422 constexpr int32_t intNum = 2;
423 MessageParcel datas;
424 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
425 datas.WriteBuffer(data, size);
426 datas.WriteInt32(intNum);
427 datas.RewindRead(0);
428 MessageParcel reply;
429 MessageOption option;
430 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
431 if (softBusClientStub == nullptr) {
432 return false;
433 }
434 softBusClientStub->OnRemoteRequest(CLIENT_ON_PERMISSION_CHANGE, datas, reply, option);
435 return true;
436 }
437
OnDiscoverFailedInnerTest(const uint8_t * data,size_t size)438 bool OnDiscoverFailedInnerTest(const uint8_t* data, size_t size)
439 {
440 (void)size;
441 int32_t intNum = *(reinterpret_cast<const int32_t*>(data));
442 constexpr int32_t reason = 2;
443 MessageParcel datas;
444 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
445 datas.WriteInt32(intNum);
446 datas.WriteInt32(reason);
447 datas.RewindRead(0);
448 MessageParcel reply;
449 MessageOption option;
450 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
451 if (softBusClientStub == nullptr) {
452 return false;
453 }
454 softBusClientStub->OnRemoteRequest(CLIENT_DISCOVERY_FAIL, datas, reply, option);
455 return true;
456 }
457
OnDiscoverySuccessInnerTest(const uint8_t * data,size_t size)458 bool OnDiscoverySuccessInnerTest(const uint8_t* data, size_t size)
459 {
460 (void)size;
461 int32_t intNum = *(reinterpret_cast<const int32_t*>(data));
462 constexpr int32_t reason = 2;
463 MessageParcel datas;
464 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
465 datas.WriteInt32(intNum);
466 datas.WriteInt32(reason);
467 datas.RewindRead(0);
468 MessageParcel reply;
469 MessageOption option;
470 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
471 if (softBusClientStub == nullptr) {
472 return false;
473 }
474 softBusClientStub->OnRemoteRequest(CLIENT_DISCOVERY_SUCC, datas, reply, option);
475 return true;
476 }
477
OnPublishSuccessInnerTest(const uint8_t * data,size_t size)478 bool OnPublishSuccessInnerTest(const uint8_t* data, size_t size)
479 {
480 (void)size;
481 int32_t intNum = *(reinterpret_cast<const int32_t*>(data));
482 constexpr int32_t reason = 2;
483 MessageParcel datas;
484 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
485 datas.WriteInt32(intNum);
486 datas.WriteInt32(reason);
487 datas.RewindRead(0);
488 MessageParcel reply;
489 MessageOption option;
490 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
491 if (softBusClientStub == nullptr) {
492 return false;
493 }
494 softBusClientStub->OnRemoteRequest(CLIENT_PUBLISH_SUCC, datas, reply, option);
495 return true;
496 }
497
OnPublishFailInnerTest(const uint8_t * data,size_t size)498 bool OnPublishFailInnerTest(const uint8_t* data, size_t size)
499 {
500 (void)size;
501 int32_t intNum = *(reinterpret_cast<const int32_t*>(data));
502 constexpr int32_t reason = 2;
503 MessageParcel datas;
504 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
505 datas.WriteInt32(intNum);
506 datas.WriteInt32(reason);
507 datas.RewindRead(0);
508 MessageParcel reply;
509 MessageOption option;
510 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
511 if (softBusClientStub == nullptr) {
512 return false;
513 }
514 softBusClientStub->OnRemoteRequest(CLIENT_PUBLISH_FAIL, datas, reply, option);
515 return true;
516 }
517 }
518
519 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)520 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
521 {
522 /* Run your code on data */
523 if (data == nullptr) {
524 return 0;
525 }
526
527 if (size < OHOS::U32_AT_SIZE) {
528 return 0;
529 }
530
531 /* Validate the length of size */
532 if (size > OHOS::FOO_MAX_LEN) {
533 return 0;
534 }
535 OHOS::OnChannelOpenedInnerTest(data, size);
536 OHOS::OnChannelOpenFailedInnerTest(data, size);
537 OHOS::OnChannelLinkDownInnerTest(data, size);
538 OHOS::OnChannelClosedInnerTest(data, size);
539 OHOS::OnChannelMsgReceivedInnerTest(data, size);
540 OHOS::OnChannelQosEventInnerTest(data, size);
541 OHOS::OnDeviceFoundInnerTest(data, size);
542 OHOS::OnJoinLNNResultInnerTest(data, size);
543 OHOS::OnJoinMetaNodeResultInnerTest(data, size);
544 OHOS::OnLeaveLNNResultInnerTest(data, size);
545 OHOS::OnLeaveMetaNodeResultInnerTest(data, size);
546 OHOS::OnNodeOnlineStateChangedInnerTest(data, size);
547 OHOS::OnNodeBasicInfoChangedInnerTest(data, size);
548 OHOS::OnTimeSyncResultInnerTest(data, size);
549 OHOS::OnPublishLNNResultInnerTest(data, size);
550 OHOS::OnRefreshLNNResultInnerTest(data, size);
551 OHOS::OnRefreshDeviceFoundInnerTest(data, size);
552 OHOS::OnClientPermissonChangeInnerTest(data, size);
553 OHOS::OnDiscoverFailedInnerTest(data, size);
554 OHOS::OnDiscoverySuccessInnerTest(data, size);
555 OHOS::OnPublishSuccessInnerTest(data, size);
556 OHOS::OnPublishFailInnerTest(data, size);
557 return 0;
558 }
559