1 /*
2 * Copyright (c) 2022-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 <securec.h>
17 #include <thread>
18
19 #include "common_net_conn_callback_test.h"
20 #include "i_net_supplier_callback.h"
21 #include "iservice_registry.h"
22 #include "net_conn_constants.h"
23 #include "net_mgr_log_wrapper.h"
24 #include "netmanager_base_test_security.h"
25 #include "system_ability_definition.h"
26 #define private public
27 #include "net_conn_client.h"
28 #include "net_conn_service.h"
29 #include "net_conn_service_stub.h"
30 #include "net_interface_callback_stub.h"
31 #include "net_mgr_log_wrapper.h"
32 #include "net_factoryreset_callback_stub.h"
33
34 namespace OHOS {
35 namespace NetManagerStandard {
36 namespace {
37 const uint8_t *g_baseFuzzData = nullptr;
38 static constexpr uint32_t CREATE_NET_TYPE_VALUE = 7;
39 static constexpr uint8_t WITH_ALL_PARM_MODEL = 0;
40 static constexpr uint8_t WITHOUT_FIRST_PARM_MODEL = 1;
41 static constexpr uint8_t WITHOUT_SECOND_PARM_MODEL = 2;
42 static constexpr uint8_t WITHOUT_THIRD_PARM_MODEL = 3;
43 static constexpr uint8_t WITHOUT_FOURTH_PARM_MODEL = 4;
44 static constexpr int32_t MAX_JUMP_NUMBER = 30;
45 size_t g_baseFuzzSize = 0;
46 size_t g_baseFuzzPos;
47 constexpr size_t STR_LEN = 10;
48 } // namespace
49
NetConnGetData()50 template <class T> T NetConnGetData()
51 {
52 T object{};
53 size_t netConnSize = sizeof(object);
54 if (g_baseFuzzData == nullptr || netConnSize > g_baseFuzzSize - g_baseFuzzPos) {
55 return object;
56 }
57 errno_t ret = memcpy_s(&object, netConnSize, g_baseFuzzData + g_baseFuzzPos, netConnSize);
58 if (ret != EOK) {
59 return {};
60 }
61 g_baseFuzzPos += netConnSize;
62 return object;
63 }
64
NetConnGetString(int strlen)65 std::string NetConnGetString(int strlen)
66 {
67 char cstr[strlen];
68 cstr[strlen - 1] = '\0';
69 for (int i = 0; i < strlen - 1; i++) {
70 cstr[i] = NetConnGetData<char>();
71 }
72 std::string str(cstr);
73 return str;
74 }
75
GetSecureDataFromData(int8_t strlen)76 SecureData GetSecureDataFromData(int8_t strlen)
77 {
78 SecureData secureData;
79 char cstr[strlen];
80 cstr[strlen - 1] = '\0';
81 for (int i = 0; i < strlen - 1; i++) {
82 cstr[i] = NetConnGetData<char>();
83 }
84 secureData.append(cstr, strlen-1);
85 return secureData;
86 }
87
88 class INetDetectionCallbackTest : public IRemoteStub<INetDetectionCallback> {
89 public:
OnNetDetectionResultChanged(NetDetectionResultCode detectionResult,const std::string & urlRedirect)90 virtual int32_t OnNetDetectionResultChanged(NetDetectionResultCode detectionResult, const std::string &urlRedirect)
91 {
92 return 0;
93 }
94 };
95
96 class NetInterfaceStateCallbackTest : public NetInterfaceStateCallbackStub {};
97
98 static bool g_isInited = false;
Init()99 void Init()
100 {
101 if (!g_isInited) {
102 if (!DelayedSingleton<NetConnService>::GetInstance()->Init()) {
103 g_isInited = false;
104 } else {
105 g_isInited = true;
106 }
107 }
108 }
109
OnRemoteRequest(uint32_t code,MessageParcel & data)110 int32_t OnRemoteRequest(uint32_t code, MessageParcel &data)
111 {
112 if (!g_isInited) {
113 NETMGR_LOG_D("Net conn client fuzz test g_isInited is false.");
114 Init();
115 }
116
117 MessageParcel reply;
118 MessageOption option;
119
120 int32_t ret = DelayedSingleton<NetConnService>::GetInstance()->OnRemoteRequest(code, data, reply, option);
121 return ret;
122 }
123
WriteInterfaceToken(MessageParcel & data)124 bool WriteInterfaceToken(MessageParcel &data)
125 {
126 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
127 NETMGR_LOG_D("Write token failed.");
128 return false;
129 }
130 return true;
131 }
132
IsConnClientDataAndSizeValid(const uint8_t * data,size_t size,MessageParcel & dataParcel)133 bool IsConnClientDataAndSizeValid(const uint8_t *data, size_t size, MessageParcel &dataParcel)
134 {
135 g_baseFuzzData = data;
136 g_baseFuzzSize = size;
137 g_baseFuzzPos = 0;
138
139 if (!WriteInterfaceToken(dataParcel)) {
140 return false;
141 }
142 return true;
143 }
144
SetAppHttpProxyCallback(const HttpProxy & httpProxy)145 void SetAppHttpProxyCallback(const HttpProxy &httpProxy)
146 {
147 return;
148 }
149
SystemReadyFuzzTest(const uint8_t * data,size_t size)150 void SystemReadyFuzzTest(const uint8_t *data, size_t size)
151 {
152 NetManagerBaseAccessToken token;
153
154 MessageParcel dataParcel;
155 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
156 return;
157 }
158 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SYSTEM_READY), dataParcel);
159 }
160
RegisterNetSupplierFuzzTest(const uint8_t * data,size_t size)161 void RegisterNetSupplierFuzzTest(const uint8_t *data, size_t size)
162 {
163 NetManagerBaseAccessToken token;
164 MessageParcel dataParcel;
165 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
166 return;
167 }
168 uint32_t bearerType = NetConnGetData<uint32_t>() % CREATE_NET_TYPE_VALUE;
169 dataParcel.WriteUint32(bearerType);
170
171 std::string ident = NetConnGetString(STR_LEN);
172 dataParcel.WriteString(ident);
173
174 std::set<NetCap> netCaps{NET_CAPABILITY_INTERNET, NET_CAPABILITY_MMS};
175 uint32_t capsSize = static_cast<uint32_t>(netCaps.size());
176 dataParcel.WriteUint32(capsSize);
177 for (auto netCap : netCaps) {
178 dataParcel.WriteUint32(static_cast<uint32_t>(netCap));
179 }
180
181 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REG_NET_SUPPLIER), dataParcel);
182 }
183
UnregisterNetSupplierFuzzTest(const uint8_t * data,size_t size)184 void UnregisterNetSupplierFuzzTest(const uint8_t *data, size_t size)
185 {
186 NetManagerBaseAccessToken token;
187 uint32_t supplierId = NetConnGetData<uint32_t>();
188 MessageParcel dataParcel;
189 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
190 return;
191 }
192 dataParcel.WriteUint32(supplierId);
193 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UNREG_NETWORK), dataParcel);
194 }
195
HasDefaultNetFuzzTest(const uint8_t * data,size_t size)196 void HasDefaultNetFuzzTest(const uint8_t *data, size_t size)
197 {
198 NetManagerBaseAccessToken token;
199
200 MessageParcel dataParcel;
201 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
202 return;
203 }
204
205 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_HASDEFAULTNET), dataParcel);
206 }
207
GetAllNetsFuzzTest(const uint8_t * data,size_t size)208 void GetAllNetsFuzzTest(const uint8_t *data, size_t size)
209 {
210 if (data == nullptr) {
211 return;
212 }
213 NetManagerBaseAccessToken token;
214
215 MessageParcel dataParcel;
216 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
217 return;
218 }
219
220 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_ALL_NETS), dataParcel);
221 }
222
BindSocketFuzzTest(const uint8_t * data,size_t size)223 void BindSocketFuzzTest(const uint8_t *data, size_t size)
224 {
225 NetManagerBaseAccessToken token;
226 int32_t socketFd = NetConnGetData<int32_t>();
227 int32_t netId = NetConnGetData<int32_t>();
228 MessageParcel dataParcel;
229 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
230 return;
231 }
232 dataParcel.WriteInt32(socketFd);
233 dataParcel.WriteInt32(netId);
234 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_BIND_SOCKET), dataParcel);
235 }
236
SetAirplaneModeFuzzTest(const uint8_t * data,size_t size)237 void SetAirplaneModeFuzzTest(const uint8_t *data, size_t size)
238 {
239 NetManagerBaseAccessToken token;
240 bool state = NetConnGetData<bool>();
241
242 MessageParcel dataParcel;
243 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
244 return;
245 }
246 dataParcel.WriteBool(state);
247 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_AIRPLANE_MODE), dataParcel);
248
249 MessageParcel dataParcelNoState;
250 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoState)) {
251 return;
252 }
253
254 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_AIRPLANE_MODE), dataParcelNoState);
255 }
256
UpdateNetSupplierInfoFuzzTest(const uint8_t * data,size_t size)257 void UpdateNetSupplierInfoFuzzTest(const uint8_t *data, size_t size)
258 {
259 NetManagerBaseAccessToken token;
260 uint32_t supplierId = NetConnGetData<uint32_t>();
261 sptr<NetSupplierInfo> netSupplierInfo = new (std::nothrow) NetSupplierInfo();
262
263 MessageParcel dataParcel;
264 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
265 NETMGR_LOG_D("UpdateNetSupplierInfoFuzzTest write token failed or invalid parameter.");
266 return;
267 }
268 dataParcel.WriteUint32(supplierId);
269 netSupplierInfo->Marshalling(dataParcel);
270 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_NET_SUPPLIER_INFO), dataParcel);
271
272 MessageParcel dataParcelNoSupplierId;
273 netSupplierInfo->Marshalling(dataParcel);
274 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_NET_SUPPLIER_INFO), dataParcel);
275 }
276
GetAddressByNameFuzzTest(const uint8_t * data,size_t size)277 void GetAddressByNameFuzzTest(const uint8_t *data, size_t size)
278 {
279 NetManagerBaseAccessToken token;
280 std::string host = NetConnGetString(STR_LEN);
281 int32_t netId = NetConnGetData<int32_t>();
282
283 MessageParcel dataParcel;
284 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
285 NETMGR_LOG_D("GetAddressByNameFuzzTest write token failed or invalid parameter.");
286 return;
287 }
288 dataParcel.WriteString(host);
289 dataParcel.WriteInt32(netId);
290
291 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_ADDRESS_BY_NAME), dataParcel);
292
293 MessageParcel dataParcelNoHost;
294 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoHost)) {
295 NETMGR_LOG_D("GetAddressByNameFuzzTest write token failed or invalid parameter.");
296 return;
297 }
298 dataParcelNoHost.WriteInt32(netId);
299
300 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_ADDRESS_BY_NAME), dataParcelNoHost);
301
302 MessageParcel dataParcelNoNetId;
303 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetId)) {
304 NETMGR_LOG_D("GetAddressByNameFuzzTest write token failed or invalid parameter.");
305 return;
306 }
307 dataParcelNoNetId.WriteInt32(netId);
308
309 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_ADDRESS_BY_NAME), dataParcelNoNetId);
310 }
311
GetAddressesByNameFuzzTest(const uint8_t * data,size_t size)312 void GetAddressesByNameFuzzTest(const uint8_t *data, size_t size)
313 {
314 NetManagerBaseAccessToken token;
315 std::string host = NetConnGetString(STR_LEN);
316 int32_t netId = NetConnGetData<int32_t>();
317
318 MessageParcel dataParcel;
319 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
320 return;
321 }
322 dataParcel.WriteString(host);
323 dataParcel.WriteInt32(netId);
324
325 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_ADDRESSES_BY_NAME), dataParcel);
326
327 MessageParcel dataParcelNoHost;
328 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoHost)) {
329 return;
330 }
331 dataParcelNoHost.WriteInt32(netId);
332
333 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_ADDRESSES_BY_NAME), dataParcelNoHost);
334
335 MessageParcel dataParcelNoNetId;
336 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetId)) {
337 return;
338 }
339 dataParcelNoNetId.WriteString(host);
340
341 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_ADDRESSES_BY_NAME), dataParcelNoNetId);
342 }
343
UpdateNetLinkInfoFuzzTest(const uint8_t * data,size_t size)344 void UpdateNetLinkInfoFuzzTest(const uint8_t *data, size_t size)
345 {
346 uint32_t supplierId = NetConnGetData<uint32_t>();
347 sptr<NetLinkInfo> netLinkInfo = new (std::nothrow) NetLinkInfo();
348 if (netLinkInfo == nullptr) {
349 return;
350 }
351
352 MessageParcel dataParcel;
353 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
354 return;
355 }
356 dataParcel.WriteUint32(supplierId);
357 netLinkInfo->Marshalling(dataParcel);
358
359 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_NET_LINK_INFO), dataParcel);
360
361 MessageParcel dataParcelNoSupplierId;
362 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoSupplierId)) {
363 return;
364 }
365 netLinkInfo->Marshalling(dataParcelNoSupplierId);
366
367 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_NET_LINK_INFO), dataParcelNoSupplierId);
368 }
369
RegisterNetSupplierCallbackFuzzTest(const uint8_t * data,size_t size)370 void RegisterNetSupplierCallbackFuzzTest(const uint8_t *data, size_t size)
371 {
372 NetManagerBaseAccessToken token;
373 uint32_t supplierId = NetConnGetData<uint32_t>();
374 sptr<NetSupplierCallbackStubTestCb> callback = new (std::nothrow) NetSupplierCallbackStubTestCb();
375 if (callback == nullptr) {
376 return;
377 }
378
379 MessageParcel dataParcel;
380 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
381 return;
382 }
383 dataParcel.WriteUint32(supplierId);
384 dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
385
386 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_SUPPLIER_CALLBACK), dataParcel);
387
388 MessageParcel dataParcelNoSupplierId;
389 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
390 return;
391 }
392 dataParcelNoSupplierId.WriteRemoteObject(callback->AsObject().GetRefPtr());
393
394 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_SUPPLIER_CALLBACK),
395 dataParcelNoSupplierId);
396
397 MessageParcel dataParcelNoRemoteObject;
398 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoRemoteObject)) {
399 return;
400 }
401 dataParcelNoRemoteObject.WriteUint32(supplierId);
402
403 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_SUPPLIER_CALLBACK),
404 dataParcelNoRemoteObject);
405 }
406
RegisterNetConnCallbackBySpecifierFuzzTest(const uint8_t * data,size_t size)407 void RegisterNetConnCallbackBySpecifierFuzzTest(const uint8_t *data, size_t size)
408 {
409 NetManagerBaseAccessToken token;
410 sptr<NetSpecifier> netSpecifier = new (std::nothrow) NetSpecifier();
411 sptr<INetConnCallbackTest> callback = new (std::nothrow) INetConnCallbackTest();
412 if (netSpecifier == nullptr || callback == nullptr) {
413 return;
414 }
415 uint32_t timeoutMS = NetConnGetData<uint32_t>();
416
417 MessageParcel dataParcel;
418 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
419 return;
420 }
421 netSpecifier->Marshalling(dataParcel);
422 dataParcel.WriteUint32(timeoutMS);
423 dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
424
425 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_CONN_CALLBACK_BY_SPECIFIER),
426 dataParcel);
427
428 MessageParcel dataParcelNoNetSpecifier;
429 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetSpecifier)) {
430 return;
431 }
432 netSpecifier->Marshalling(dataParcelNoNetSpecifier);
433 dataParcelNoNetSpecifier.WriteRemoteObject(callback->AsObject().GetRefPtr());
434
435 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_CONN_CALLBACK_BY_SPECIFIER),
436 dataParcelNoNetSpecifier);
437
438 MessageParcel dataParcelNoRemoteObject;
439 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoRemoteObject)) {
440 return;
441 }
442 netSpecifier->Marshalling(dataParcelNoRemoteObject);
443 dataParcelNoRemoteObject.WriteUint32(timeoutMS);
444
445 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_CONN_CALLBACK_BY_SPECIFIER),
446 dataParcelNoRemoteObject);
447 }
448
RegisterNetConnCallbackFuzzTest(const uint8_t * data,size_t size)449 void RegisterNetConnCallbackFuzzTest(const uint8_t *data, size_t size)
450 {
451 sptr<INetConnCallbackTest> callback = new (std::nothrow) INetConnCallbackTest();
452 if (callback == nullptr) {
453 return;
454 }
455
456 MessageParcel dataParcel;
457 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
458 return;
459 }
460
461 dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
462
463 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_CONN_CALLBACK), dataParcel);
464
465 MessageParcel dataParcelNoRemoteObject;
466 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoRemoteObject)) {
467 return;
468 }
469
470 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_CONN_CALLBACK),
471 dataParcelNoRemoteObject);
472 }
473
UnregisterNetConnCallbackFuzzTest(const uint8_t * data,size_t size)474 void UnregisterNetConnCallbackFuzzTest(const uint8_t *data, size_t size)
475 {
476 if (data == nullptr) {
477 return;
478 }
479
480 NetManagerBaseAccessToken token;
481 sptr<INetConnCallbackTest> callback = new (std::nothrow) INetConnCallbackTest();
482 if (callback == nullptr) {
483 return;
484 }
485
486 MessageParcel dataParcel;
487 if (!WriteInterfaceToken(dataParcel)) {
488 return;
489 }
490 dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
491
492 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UNREGISTER_NET_CONN_CALLBACK), dataParcel);
493
494 MessageParcel dataParcelNoRemoteObject;
495 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
496 return;
497 }
498
499 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UNREGISTER_NET_CONN_CALLBACK),
500 dataParcelNoRemoteObject);
501 }
502
GetDefaultNetFuzzTest(const uint8_t * data,size_t size)503 void GetDefaultNetFuzzTest(const uint8_t *data, size_t size)
504 {
505 NetManagerBaseAccessToken token;
506
507 MessageParcel dataParcel;
508 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
509 return;
510 }
511 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GETDEFAULTNETWORK), dataParcel);
512 }
513
GetConnectionPropertiesFuzzTest(const uint8_t * data,size_t size)514 void GetConnectionPropertiesFuzzTest(const uint8_t *data, size_t size)
515 {
516 NetManagerBaseAccessToken token;
517 int32_t netId = NetConnGetData<int32_t>();
518
519 MessageParcel dataParcel;
520 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
521 return;
522 }
523 dataParcel.WriteInt32(netId);
524 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_CONNECTION_PROPERTIES), dataParcel);
525
526 MessageParcel dataParcelNoNetId;
527 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetId)) {
528 return;
529 }
530 dataParcelNoNetId.WriteInt32(netId);
531 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_CONNECTION_PROPERTIES), dataParcelNoNetId);
532 }
533
SetNetExtAttributeFuzzTest(const uint8_t * data,size_t size)534 void SetNetExtAttributeFuzzTest(const uint8_t *data, size_t size)
535 {
536 NetManagerBaseAccessToken token;
537 int32_t netId = NetConnGetData<int32_t>();
538 std::string netExtAttr = NetConnGetString(STR_LEN);
539
540 MessageParcel dataParcel;
541 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
542 return;
543 }
544
545 dataParcel.WriteInt32(netId);
546 dataParcel.WriteString(netExtAttr);
547 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_NET_EXT_ATTRIBUTE), dataParcel);
548
549 MessageParcel dataParcelNoNetId;
550 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetId)) {
551 return;
552 }
553 dataParcelNoNetId.WriteString(netExtAttr);
554 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_NET_EXT_ATTRIBUTE), dataParcelNoNetId);
555
556 MessageParcel dataParcelNoNetExtAttr;
557 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetExtAttr)) {
558 return;
559 }
560 dataParcelNoNetExtAttr.WriteInt32(netId);
561 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_NET_EXT_ATTRIBUTE), dataParcelNoNetExtAttr);
562 }
563
GetNetExtAttributeFuzzTest(const uint8_t * data,size_t size)564 void GetNetExtAttributeFuzzTest(const uint8_t *data, size_t size)
565 {
566 NetManagerBaseAccessToken token;
567 int32_t netId = NetConnGetData<int32_t>();
568 std::string netExtAttr = NetConnGetString(STR_LEN);
569
570 MessageParcel dataParcel;
571 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
572 return;
573 }
574
575 dataParcel.WriteInt32(netId);
576 dataParcel.WriteString(netExtAttr);
577 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_NET_EXT_ATTRIBUTE), dataParcel);
578
579 MessageParcel dataParcelNoNetId;
580 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetId)) {
581 return;
582 }
583 dataParcelNoNetId.WriteString(netExtAttr);
584 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_NET_EXT_ATTRIBUTE), dataParcelNoNetId);
585
586 MessageParcel dataParcelNoNetExtAttr;
587 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetExtAttr)) {
588 return;
589 }
590 dataParcelNoNetExtAttr.WriteInt32(netId);
591 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_NET_EXT_ATTRIBUTE), dataParcelNoNetExtAttr);
592 }
593
GetNetCapabilitiesFuzzTest(const uint8_t * data,size_t size)594 void GetNetCapabilitiesFuzzTest(const uint8_t *data, size_t size)
595 {
596 NetManagerBaseAccessToken token;
597 int32_t netId = NetConnGetData<int32_t>();
598
599 MessageParcel dataParcel;
600 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
601 return;
602 }
603 dataParcel.WriteInt32(netId);
604 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_NET_CAPABILITIES), dataParcel);
605
606 MessageParcel dataParcelNoNetId;
607 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetId)) {
608 return;
609 }
610 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_NET_CAPABILITIES), dataParcelNoNetId);
611 }
612
NetDetectionFuzzTest(const uint8_t * data,size_t size)613 void NetDetectionFuzzTest(const uint8_t *data, size_t size)
614 {
615 NetManagerBaseAccessToken tokenInternetInfo;
616 int32_t netId = NetConnGetData<int32_t>();
617
618 MessageParcel dataParcel;
619 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
620 return;
621 }
622 dataParcel.WriteInt32(netId);
623 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_NET_DETECTION), dataParcel);
624
625 MessageParcel dataParcelNoNetId;
626 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetId)) {
627 return;
628 }
629 dataParcelNoNetId.WriteInt32(netId);
630 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_NET_DETECTION), dataParcelNoNetId);
631 }
632
IsDefaultNetMeteredFuzzTest(const uint8_t * data,size_t size)633 void IsDefaultNetMeteredFuzzTest(const uint8_t *data, size_t size)
634 {
635 NetManagerBaseAccessToken token;
636
637 MessageParcel dataParcel;
638 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
639 return;
640 }
641 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_IS_DEFAULT_NET_METERED), dataParcel);
642 }
643
644
SetAppHttpProxyFuzzTest(const uint8_t * data,size_t size)645 void SetAppHttpProxyFuzzTest(const uint8_t *data, size_t size)
646 {
647 HttpProxy httpProxy = {NetConnGetString(STR_LEN), 0, {}};
648 MessageParcel dataParcel;
649 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
650 return;
651 }
652 DelayedSingleton<NetConnClient>::GetInstance()->SetAppHttpProxy(httpProxy);
653 }
654
RegisterAppHttpProxyCallbackFuzzTest(const uint8_t * data,size_t size)655 void RegisterAppHttpProxyCallbackFuzzTest(const uint8_t *data, size_t size)
656 {
657 uint32_t callbackId = 0;
658 MessageParcel dataParcel;
659 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
660 return;
661 }
662 DelayedSingleton<NetConnClient>::GetInstance()->RegisterAppHttpProxyCallback(SetAppHttpProxyCallback, callbackId);
663 }
664
UnregisterAppHttpProxyCallbackFuzzTest(const uint8_t * data,size_t size)665 void UnregisterAppHttpProxyCallbackFuzzTest(const uint8_t *data, size_t size)
666 {
667 int32_t callbackId = NetConnGetData<int32_t>();
668 MessageParcel dataParcel;
669 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
670 return;
671 }
672 DelayedSingleton<NetConnClient>::GetInstance()->UnregisterAppHttpProxyCallback(callbackId);
673 }
674
SetGlobalHttpProxyFuzzTest(const uint8_t * data,size_t size)675 void SetGlobalHttpProxyFuzzTest(const uint8_t *data, size_t size)
676 {
677 NetManagerBaseAccessToken token;
678 HttpProxy httpProxy = {NetConnGetString(STR_LEN), 0, {}};
679 httpProxy.SetUserName(GetSecureDataFromData(STR_LEN));
680 httpProxy.SetPassword(GetSecureDataFromData(STR_LEN));
681 MessageParcel dataParcel;
682 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
683 return;
684 }
685 httpProxy.Marshalling(dataParcel);
686 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_GLOBAL_HTTP_PROXY), dataParcel);
687 }
688
GetGlobalHttpProxyFuzzTest(const uint8_t * data,size_t size)689 void GetGlobalHttpProxyFuzzTest(const uint8_t *data, size_t size)
690 {
691 NetManagerBaseAccessToken token;
692
693 MessageParcel dataParcel;
694 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
695 return;
696 }
697 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_GLOBAL_HTTP_PROXY), dataParcel);
698 }
699
GetDefaultHttpProxyFuzzTest(const uint8_t * data,size_t size)700 void GetDefaultHttpProxyFuzzTest(const uint8_t *data, size_t size)
701 {
702 NetManagerBaseAccessToken token;
703
704 MessageParcel dataParcel;
705 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
706 return;
707 }
708 int32_t bindNetId = NetConnGetData<int32_t>();
709 dataParcel.WriteInt32(bindNetId);
710 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_DEFAULT_HTTP_PROXY), dataParcel);
711 }
712
GetNetIdByIdentifierFuzzTest(const uint8_t * data,size_t size)713 void GetNetIdByIdentifierFuzzTest(const uint8_t *data, size_t size)
714 {
715 NetManagerBaseAccessToken token;
716 std::string ident = NetConnGetString(STR_LEN);
717
718 MessageParcel dataParcel;
719 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
720 return;
721 }
722 dataParcel.WriteString(ident);
723 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_NET_ID_BY_IDENTIFIER), dataParcel);
724
725 MessageParcel dataParcelNoIdent;
726 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoIdent)) {
727 return;
728 }
729 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_NET_ID_BY_IDENTIFIER), dataParcelNoIdent);
730 }
731
RegisterNetInterfaceCallbackFuzzTest(const uint8_t * data,size_t size)732 void RegisterNetInterfaceCallbackFuzzTest(const uint8_t *data, size_t size)
733 {
734 if (data == nullptr) {
735 return;
736 }
737
738 NetManagerBaseAccessToken token;
739 sptr<INetInterfaceStateCallback> callback = new (std::nothrow) NetInterfaceStateCallbackTest();
740 if (callback == nullptr) {
741 return;
742 }
743
744 MessageParcel dataParcel;
745 if (!WriteInterfaceToken(dataParcel)) {
746 return;
747 }
748 dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
749 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_INTERFACE_CALLBACK), dataParcel);
750
751 MessageParcel dataParcelNoRemoteObject;
752 if (!WriteInterfaceToken(dataParcelNoRemoteObject)) {
753 return;
754 }
755 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
756 return;
757 }
758 dataParcelNoRemoteObject.WriteRemoteObject(callback->AsObject().GetRefPtr());
759 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_INTERFACE_CALLBACK),
760 dataParcelNoRemoteObject);
761 }
762
UnregisterNetInterfaceCallbackFuzzTest(const uint8_t * data,size_t size)763 void UnregisterNetInterfaceCallbackFuzzTest(const uint8_t *data, size_t size)
764 {
765 if (data == nullptr) {
766 return;
767 }
768
769 NetManagerBaseAccessToken token;
770 sptr<INetInterfaceStateCallback> callback = new (std::nothrow) NetInterfaceStateCallbackTest();
771 if (callback == nullptr) {
772 return;
773 }
774
775 MessageParcel dataParcel;
776 if (!WriteInterfaceToken(dataParcel)) {
777 return;
778 }
779 dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
780 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UNREGISTER_NET_INTERFACE_CALLBACK),
781 dataParcel);
782
783 MessageParcel dataParcelNoRemoteObject;
784 if (!WriteInterfaceToken(dataParcelNoRemoteObject)) {
785 return;
786 }
787 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
788 return;
789 }
790 dataParcelNoRemoteObject.WriteRemoteObject(callback->AsObject().GetRefPtr());
791 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UNREGISTER_NET_INTERFACE_CALLBACK),
792 dataParcelNoRemoteObject);
793 }
794
GetNetInterfaceConfigurationFuzzTest(const uint8_t * data,size_t size)795 void GetNetInterfaceConfigurationFuzzTest(const uint8_t *data, size_t size)
796 {
797 NetManagerBaseAccessToken token;
798 std::string iface = NetConnGetString(STR_LEN);
799
800 MessageParcel dataParcel;
801 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
802 return;
803 }
804 dataParcel.WriteString(iface);
805 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_INTERFACE_CONFIGURATION), dataParcel);
806
807 MessageParcel dataParcelNoIface;
808 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoIface)) {
809 return;
810 }
811 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_INTERFACE_CONFIGURATION), dataParcelNoIface);
812 }
813
SetInternetPermissionFuzzTest(const uint8_t * data,size_t size)814 void SetInternetPermissionFuzzTest(const uint8_t *data, size_t size)
815 {
816 uint32_t uid = NetConnGetData<uint32_t>();
817 uint8_t allow = NetConnGetData<uint8_t>();
818
819 NetManagerBaseAccessToken token;
820 MessageParcel dataParcel;
821 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
822 return;
823 }
824
825 dataParcel.WriteUint32(uid);
826 dataParcel.WriteUint8(allow);
827 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_INTERNET_PERMISSION), dataParcel);
828
829 MessageParcel dataParcelNoUid;
830 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoUid)) {
831 return;
832 }
833
834 dataParcelNoUid.WriteUint8(allow);
835 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_INTERNET_PERMISSION), dataParcelNoUid);
836
837 MessageParcel dataParcelNoAllow;
838 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoAllow)) {
839 return;
840 }
841
842 dataParcel.WriteUint32(uid);
843 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_INTERNET_PERMISSION), dataParcelNoAllow);
844 }
845
UpdateNetStateForTestFuzzTest(const uint8_t * data,size_t size)846 void UpdateNetStateForTestFuzzTest(const uint8_t *data, size_t size)
847 {
848 sptr<NetSpecifier> netSpecifier = new (std::nothrow) NetSpecifier();
849 if (netSpecifier == nullptr) {
850 return;
851 }
852 auto netState = NetConnGetData<int32_t>();
853
854 MessageParcel dataParcel;
855 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
856 NETMGR_LOG_D("UpdateNetSupplierInfoFuzzTest write token failed or invalid parameter.");
857 return;
858 }
859
860 netSpecifier->Marshalling(dataParcel);
861 dataParcel.WriteInt32(netState);
862 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UPDATE_NET_STATE_FOR_TEST), dataParcel);
863
864 MessageParcel dataParcelNoNetState;
865 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetState)) {
866 NETMGR_LOG_D("UpdateNetSupplierInfoFuzzTest write token failed or invalid parameter.");
867 return;
868 }
869
870 netSpecifier->Marshalling(dataParcelNoNetState);
871 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UPDATE_NET_STATE_FOR_TEST), dataParcelNoNetState);
872 }
873
GetIfaceNamesFuzzTest(const uint8_t * data,size_t size)874 void GetIfaceNamesFuzzTest(const uint8_t *data, size_t size)
875 {
876 uint32_t bearerType = NetConnGetData<uint32_t>() % CREATE_NET_TYPE_VALUE;
877
878 MessageParcel dataParcel;
879 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
880 NETMGR_LOG_D("GetIfaceNamesFuzzTest write token failed or invalid parameter.");
881 return;
882 }
883
884 dataParcel.WriteUint32(bearerType);
885
886 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_IFACE_NAMES), dataParcel);
887
888 MessageParcel dataParcelNoBearerType;
889 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoBearerType)) {
890 NETMGR_LOG_D("GetIfaceNamesFuzzTest write token failed or invalid parameter.");
891 return;
892 }
893
894 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_IFACE_NAMES), dataParcelNoBearerType);
895 }
896
GetIfaceNameByTypeFuzzTest(const uint8_t * data,size_t size)897 void GetIfaceNameByTypeFuzzTest(const uint8_t *data, size_t size)
898 {
899 uint32_t bearerType = NetConnGetData<uint32_t>() % CREATE_NET_TYPE_VALUE;
900 std::string ident = NetConnGetString(STR_LEN);
901
902 MessageParcel dataParcel;
903 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
904 NETMGR_LOG_D("GetIfaceNameByTypeFuzzTest write token failed or invalid parameter.");
905 return;
906 }
907
908 dataParcel.WriteUint32(bearerType);
909 dataParcel.WriteString(ident);
910
911 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_IFACENAME_BY_TYPE), dataParcel);
912
913 MessageParcel dataParcelNoBearerType;
914 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoBearerType)) {
915 NETMGR_LOG_D("GetIfaceNameByTypeFuzzTest write token failed or invalid parameter.");
916 return;
917 }
918
919 dataParcelNoBearerType.WriteString(ident);
920
921 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_IFACENAME_BY_TYPE), dataParcelNoBearerType);
922
923 MessageParcel dataParcelNoIdent;
924 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoIdent)) {
925 NETMGR_LOG_D("GetIfaceNameByTypeFuzzTest write token failed or invalid parameter.");
926 return;
927 }
928
929 dataParcel.WriteUint32(bearerType);
930 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_IFACENAME_BY_TYPE), dataParcelNoIdent);
931 }
932
RegisterNetDetectionCallbackFuzzTest(const uint8_t * data,size_t size)933 void RegisterNetDetectionCallbackFuzzTest(const uint8_t *data, size_t size)
934 {
935 int32_t netId = NetConnGetData<int32_t>();
936 sptr<INetDetectionCallbackTest> callback = new (std::nothrow) INetDetectionCallbackTest();
937 if (callback == nullptr) {
938 return;
939 }
940
941 MessageParcel dataParcel;
942 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
943 return;
944 }
945
946 dataParcel.WriteInt32(netId);
947 dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
948
949 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_DETECTION_RET_CALLBACK),
950 dataParcel);
951
952 MessageParcel dataParcelNoNetId;
953 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetId)) {
954 return;
955 }
956
957 dataParcelNoNetId.WriteRemoteObject(callback->AsObject().GetRefPtr());
958
959 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_DETECTION_RET_CALLBACK),
960 dataParcelNoNetId);
961
962 MessageParcel dataParcelNoRemoteObject;
963 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoRemoteObject)) {
964 return;
965 }
966 dataParcelNoRemoteObject.WriteInt32(netId);
967 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_DETECTION_RET_CALLBACK),
968 dataParcelNoRemoteObject);
969 }
970
UnRegisterNetDetectionCallbackFuzzTest(const uint8_t * data,size_t size)971 void UnRegisterNetDetectionCallbackFuzzTest(const uint8_t *data, size_t size)
972 {
973 int32_t netId = NetConnGetData<int32_t>();
974 sptr<INetDetectionCallbackTest> callback = new (std::nothrow) INetDetectionCallbackTest();
975 if (callback == nullptr) {
976 return;
977 }
978
979 MessageParcel dataParcel;
980 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
981 return;
982 }
983
984 dataParcel.WriteInt32(netId);
985 dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
986
987 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UNREGISTER_NET_DETECTION_RET_CALLBACK),
988 dataParcel);
989
990 MessageParcel dataParcelNoNetId;
991 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetId)) {
992 return;
993 }
994
995 dataParcelNoNetId.WriteRemoteObject(callback->AsObject().GetRefPtr());
996
997 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UNREGISTER_NET_DETECTION_RET_CALLBACK),
998 dataParcelNoNetId);
999
1000 MessageParcel dataParcelNoRemoteObject;
1001 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1002 return;
1003 }
1004
1005 dataParcelNoRemoteObject.WriteInt32(netId);
1006
1007 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UNREGISTER_NET_DETECTION_RET_CALLBACK),
1008 dataParcelNoRemoteObject);
1009 }
1010
GetSpecificNetFuzzTest(const uint8_t * data,size_t size)1011 void GetSpecificNetFuzzTest(const uint8_t *data, size_t size)
1012 {
1013 uint32_t bearerType = NetConnGetData<uint32_t>() % CREATE_NET_TYPE_VALUE;
1014
1015 MessageParcel dataParcel;
1016 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1017 return;
1018 }
1019
1020 dataParcel.WriteUint32(bearerType);
1021
1022 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_SPECIFIC_NET), dataParcel);
1023
1024 MessageParcel dataParcelNoBearerType;
1025 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoBearerType)) {
1026 return;
1027 }
1028
1029 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_SPECIFIC_NET), dataParcelNoBearerType);
1030 }
1031
GetSpecificNetByIdentFuzzTest(const uint8_t * data,size_t size)1032 void GetSpecificNetByIdentFuzzTest(const uint8_t *data, size_t size)
1033 {
1034 uint32_t bearerType = NetConnGetData<uint32_t>() % CREATE_NET_TYPE_VALUE;
1035 std::string ident = NetConnGetString(STR_LEN);
1036
1037 MessageParcel dataParcel;
1038 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1039 return;
1040 }
1041
1042 dataParcel.WriteUint32(bearerType);
1043 dataParcel.WriteString(ident);
1044
1045 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_SPECIFIC_NET_BY_IDENT), dataParcel);
1046
1047 MessageParcel dataParcelNoBearerType;
1048 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoBearerType)) {
1049 return;
1050 }
1051 dataParcel.WriteString(ident);
1052
1053 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_SPECIFIC_NET_BY_IDENT), dataParcelNoBearerType);
1054
1055 MessageParcel dataParcelNoIdent;
1056 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoIdent)) {
1057 return;
1058 }
1059 dataParcel.WriteUint32(bearerType);
1060
1061 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_SPECIFIC_NET_BY_IDENT), dataParcelNoIdent);
1062 }
1063
OnSetAppNetFuzzTest(const uint8_t * data,size_t size)1064 void OnSetAppNetFuzzTest(const uint8_t *data, size_t size)
1065 {
1066 int32_t netId = NetConnGetData<int32_t>();
1067
1068 MessageParcel dataParcel;
1069 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1070 return;
1071 }
1072
1073 dataParcel.WriteInt32(netId);
1074
1075 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_APP_NET), dataParcel);
1076
1077 MessageParcel dataParcelNoNetId;
1078 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetId)) {
1079 return;
1080 }
1081
1082 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_APP_NET), dataParcelNoNetId);
1083 }
1084
GetSpecificUidNetFuzzTest(const uint8_t * data,size_t size)1085 void GetSpecificUidNetFuzzTest(const uint8_t *data, size_t size)
1086 {
1087 int32_t uid = NetConnGetData<int32_t>();
1088 int32_t netId = NetConnGetData<int32_t>();
1089
1090 MessageParcel dataParcel;
1091 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1092 return;
1093 }
1094
1095 dataParcel.WriteInt32(uid);
1096 dataParcel.WriteInt32(netId);
1097
1098 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_SPECIFIC_UID_NET), dataParcel);
1099
1100 MessageParcel dataParcelNoUid;
1101 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoUid)) {
1102 return;
1103 }
1104
1105 dataParcelNoUid.WriteInt32(netId);
1106
1107 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_SPECIFIC_UID_NET), dataParcelNoUid);
1108
1109 MessageParcel dataParcelNoNetId;
1110 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetId)) {
1111 return;
1112 }
1113 dataParcel.WriteInt32(uid);
1114 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_SPECIFIC_UID_NET), dataParcelNoNetId);
1115 }
1116
AddNetworkRouteFuzzTest(const uint8_t * data,size_t size)1117 void AddNetworkRouteFuzzTest(const uint8_t *data, size_t size)
1118 {
1119 int32_t netId = NetConnGetData<int32_t>();
1120 std::string ifName = NetConnGetString(STR_LEN);
1121 std::string destination = NetConnGetString(STR_LEN);
1122 std::string nextHop = NetConnGetString(STR_LEN);
1123 MessageParcel dataParcel;
1124 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1125 NETMGR_LOG_D("AddNetworkRouteFuzzTest write token failed or invalid parameter.");
1126 return;
1127 }
1128 dataParcel.WriteInt32(netId);
1129 dataParcel.WriteString(ifName);
1130 dataParcel.WriteString(destination);
1131 dataParcel.WriteString(nextHop);
1132 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_NET_ROUTE), dataParcel);
1133 MessageParcel dataParcelNoNetId;
1134 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetId)) {
1135 NETMGR_LOG_D("AddNetworkRouteFuzzTest write token failed or invalid parameter.");
1136 return;
1137 }
1138 dataParcelNoNetId.WriteString(ifName);
1139 dataParcelNoNetId.WriteString(destination);
1140 dataParcelNoNetId.WriteString(nextHop);
1141 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_NET_ROUTE), dataParcelNoNetId);
1142 MessageParcel dataParcelNoIfName;
1143 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoIfName)) {
1144 NETMGR_LOG_D("AddNetworkRouteFuzzTest write token failed or invalid parameter.");
1145 return;
1146 }
1147 dataParcelNoIfName.WriteInt32(netId);
1148 dataParcelNoIfName.WriteString(destination);
1149 dataParcelNoIfName.WriteString(nextHop);
1150 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_NET_ROUTE), dataParcelNoIfName);
1151 MessageParcel dataParcelNoDest;
1152 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoDest)) {
1153 NETMGR_LOG_D("AddNetworkRouteFuzzTest write token failed or invalid parameter.");
1154 return;
1155 }
1156 dataParcelNoDest.WriteInt32(netId);
1157 dataParcelNoDest.WriteString(ifName);
1158 dataParcelNoDest.WriteString(nextHop);
1159 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_NET_ROUTE), dataParcelNoDest);
1160 }
1161
RemoveNetworkRouteFuzzTest(const uint8_t * data,size_t size)1162 void RemoveNetworkRouteFuzzTest(const uint8_t *data, size_t size)
1163 {
1164 int32_t netId = NetConnGetData<int32_t>();
1165 std::string ifName = NetConnGetString(STR_LEN);
1166 std::string destination = NetConnGetString(STR_LEN);
1167 std::string nextHop = NetConnGetString(STR_LEN);
1168 MessageParcel dataParcel;
1169 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1170 NETMGR_LOG_D("RemoveNetworkRouteFuzzTest write token failed or invalid parameter.");
1171 return;
1172 }
1173 dataParcel.WriteInt32(netId);
1174 dataParcel.WriteString(ifName);
1175 dataParcel.WriteString(destination);
1176 dataParcel.WriteString(nextHop);
1177 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REMOVE_NET_ROUTE), dataParcel);
1178 MessageParcel dataParcelNoNetId;
1179 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetId)) {
1180 NETMGR_LOG_D("RemoveNetworkRouteFuzzTest write token failed or invalid parameter.");
1181 return;
1182 }
1183 dataParcelNoNetId.WriteString(ifName);
1184 dataParcelNoNetId.WriteString(destination);
1185 dataParcelNoNetId.WriteString(nextHop);
1186 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REMOVE_NET_ROUTE), dataParcelNoNetId);
1187 MessageParcel dataParcelNoIfName;
1188 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoIfName)) {
1189 NETMGR_LOG_D("RemoveNetworkRouteFuzzTest write token failed or invalid parameter.");
1190 return;
1191 }
1192 dataParcelNoIfName.WriteInt32(netId);
1193 dataParcelNoIfName.WriteString(destination);
1194 dataParcelNoIfName.WriteString(nextHop);
1195 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REMOVE_NET_ROUTE), dataParcelNoIfName);
1196 MessageParcel dataParcelNoDest;
1197 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoDest)) {
1198 NETMGR_LOG_D("RemoveNetworkRouteFuzzTest write token failed or invalid parameter.");
1199 return;
1200 }
1201 dataParcelNoDest.WriteInt32(netId);
1202 dataParcelNoDest.WriteString(ifName);
1203 dataParcelNoDest.WriteString(nextHop);
1204 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REMOVE_NET_ROUTE), dataParcelNoDest);
1205 }
1206
AddInterfaceAddressFuzzTest(const uint8_t * data,size_t size)1207 void AddInterfaceAddressFuzzTest(const uint8_t *data, size_t size)
1208 {
1209 int32_t prefixLength = NetConnGetData<int32_t>();
1210 std::string ifName = NetConnGetString(STR_LEN);
1211 std::string ipAddr = NetConnGetString(STR_LEN);
1212
1213 MessageParcel dataParcel;
1214 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1215 NETMGR_LOG_D("AddInterfaceAddressFuzzTest write token failed or invalid parameter.");
1216 return;
1217 }
1218 dataParcel.WriteString(ifName);
1219 dataParcel.WriteString(ipAddr);
1220 dataParcel.WriteInt32(prefixLength);
1221
1222 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_NET_ADDRESS), dataParcel);
1223
1224 MessageParcel dataParcelNoIfName;
1225 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoIfName)) {
1226 NETMGR_LOG_D("AddInterfaceAddressFuzzTest write token failed or invalid parameter.");
1227 return;
1228 }
1229 dataParcelNoIfName.WriteString(ipAddr);
1230 dataParcelNoIfName.WriteInt32(prefixLength);
1231
1232 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_NET_ADDRESS), dataParcelNoIfName);
1233
1234 MessageParcel dataParcelNoIpAddr;
1235 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoIpAddr)) {
1236 NETMGR_LOG_D("AddInterfaceAddressFuzzTest write token failed or invalid parameter.");
1237 return;
1238 }
1239 dataParcelNoIpAddr.WriteString(ifName);
1240 dataParcelNoIpAddr.WriteInt32(prefixLength);
1241
1242 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_NET_ADDRESS), dataParcelNoIpAddr);
1243
1244 MessageParcel dataParcelNoPrefix;
1245 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoPrefix)) {
1246 NETMGR_LOG_D("AddInterfaceAddressFuzzTest write token failed or invalid parameter.");
1247 return;
1248 }
1249 dataParcelNoPrefix.WriteString(ifName);
1250 dataParcelNoPrefix.WriteString(ipAddr);
1251
1252 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_NET_ADDRESS), dataParcelNoPrefix);
1253 }
1254
DelInterfaceAddressFuzzTest(const uint8_t * data,size_t size)1255 void DelInterfaceAddressFuzzTest(const uint8_t *data, size_t size)
1256 {
1257 int32_t prefixLength = NetConnGetData<int32_t>();
1258 std::string ifName = NetConnGetString(STR_LEN);
1259 std::string ipAddr = NetConnGetString(STR_LEN);
1260
1261 MessageParcel dataParcel;
1262 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1263 NETMGR_LOG_D("DelInterfaceAddressFuzzTest write token failed or invalid parameter.");
1264 return;
1265 }
1266 dataParcel.WriteString(ifName);
1267 dataParcel.WriteString(ipAddr);
1268 dataParcel.WriteInt32(prefixLength);
1269
1270 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REMOVE_NET_ADDRESS), dataParcel);
1271
1272 MessageParcel dataParcelNoIfName;
1273 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoIfName)) {
1274 NETMGR_LOG_D("DelInterfaceAddressFuzzTest write token failed or invalid parameter.");
1275 return;
1276 }
1277 dataParcelNoIfName.WriteString(ipAddr);
1278 dataParcelNoIfName.WriteInt32(prefixLength);
1279
1280 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REMOVE_NET_ADDRESS), dataParcelNoIfName);
1281
1282 MessageParcel dataParcelNoIpAddr;
1283 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoIpAddr)) {
1284 NETMGR_LOG_D("DelInterfaceAddressFuzzTest write token failed or invalid parameter.");
1285 return;
1286 }
1287 dataParcelNoIpAddr.WriteString(ifName);
1288 dataParcelNoIpAddr.WriteInt32(prefixLength);
1289
1290 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REMOVE_NET_ADDRESS), dataParcelNoIpAddr);
1291
1292 MessageParcel dataParcelNoPrefix;
1293 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoPrefix)) {
1294 NETMGR_LOG_D("DelInterfaceAddressFuzzTest write token failed or invalid parameter.");
1295 return;
1296 }
1297 dataParcelNoPrefix.WriteString(ifName);
1298 dataParcelNoPrefix.WriteString(ipAddr);
1299
1300 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REMOVE_NET_ADDRESS), dataParcelNoPrefix);
1301 }
1302
StaticArpProcess(const uint8_t * data,size_t size,MessageParcel & dataParcel)1303 void StaticArpProcess(const uint8_t *data, size_t size, MessageParcel &dataParcel)
1304 {
1305 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1306 return;
1307 }
1308
1309 std::string ipAddr = NetConnGetString(STR_LEN);
1310 std::string macAddr = NetConnGetString(STR_LEN);
1311 std::string ifName = NetConnGetString(STR_LEN);
1312 dataParcel.WriteString(ipAddr);
1313 dataParcel.WriteString(macAddr);
1314 dataParcel.WriteString(ifName);
1315 }
1316
StaticArpProcessNoIpAddr(const uint8_t * data,size_t size,MessageParcel & dataParcel)1317 void StaticArpProcessNoIpAddr(const uint8_t *data, size_t size, MessageParcel &dataParcel)
1318 {
1319 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1320 return;
1321 }
1322
1323 std::string macAddr = NetConnGetString(STR_LEN);
1324 std::string ifName = NetConnGetString(STR_LEN);
1325 dataParcel.WriteString(macAddr);
1326 dataParcel.WriteString(ifName);
1327 }
1328
StaticArpProcessNoMacAddr(const uint8_t * data,size_t size,MessageParcel & dataParcel)1329 void StaticArpProcessNoMacAddr(const uint8_t *data, size_t size, MessageParcel &dataParcel)
1330 {
1331 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1332 return;
1333 }
1334
1335 std::string ipAddr = NetConnGetString(STR_LEN);
1336 std::string ifName = NetConnGetString(STR_LEN);
1337 dataParcel.WriteString(ipAddr);
1338 dataParcel.WriteString(ifName);
1339 }
1340
StaticArpProcessNoIfName(const uint8_t * data,size_t size,MessageParcel & dataParcel)1341 void StaticArpProcessNoIfName(const uint8_t *data, size_t size, MessageParcel &dataParcel)
1342 {
1343 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1344 return;
1345 }
1346
1347 std::string ipAddr = NetConnGetString(STR_LEN);
1348 std::string macAddr = NetConnGetString(STR_LEN);
1349 dataParcel.WriteString(ipAddr);
1350 dataParcel.WriteString(macAddr);
1351 }
1352
AddStaticArpFuzzTest(const uint8_t * data,size_t size)1353 void AddStaticArpFuzzTest(const uint8_t *data, size_t size)
1354 {
1355 MessageParcel dataParcel;
1356 StaticArpProcess(data, size, dataParcel);
1357 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_STATIC_ARP), dataParcel);
1358
1359 MessageParcel dataParcelNoIpAddr;
1360 StaticArpProcessNoIpAddr(data, size, dataParcelNoIpAddr);
1361 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_STATIC_ARP), dataParcelNoIpAddr);
1362
1363 MessageParcel dataParcelNoMacAddr;
1364 StaticArpProcessNoMacAddr(data, size, dataParcelNoMacAddr);
1365 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_STATIC_ARP), dataParcelNoMacAddr);
1366
1367 MessageParcel dataParcelNoIfName;
1368 StaticArpProcessNoIfName(data, size, dataParcelNoIfName);
1369 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_STATIC_ARP), dataParcelNoIfName);
1370 }
1371
DelStaticArpFuzzTest(const uint8_t * data,size_t size)1372 void DelStaticArpFuzzTest(const uint8_t *data, size_t size)
1373 {
1374 MessageParcel dataParcel;
1375 StaticArpProcess(data, size, dataParcel);
1376 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_DEL_STATIC_ARP), dataParcel);
1377
1378 MessageParcel dataParcelNoIpAddr;
1379 StaticArpProcessNoIpAddr(data, size, dataParcel);
1380 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_DEL_STATIC_ARP), dataParcelNoIpAddr);
1381
1382 MessageParcel dataParcelNoMacAddr;
1383 StaticArpProcessNoMacAddr(data, size, dataParcel);
1384 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_DEL_STATIC_ARP), dataParcelNoMacAddr);
1385
1386 MessageParcel dataParcelNoIfName;
1387 StaticArpProcessNoIfName(data, size, dataParcel);
1388 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_DEL_STATIC_ARP), dataParcelNoIfName);
1389 }
1390
StaticIpv6Process(const uint8_t * data,size_t size,MessageParcel & dataParcel)1391 void StaticIpv6Process(const uint8_t *data, size_t size, MessageParcel &dataParcel)
1392 {
1393 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1394 return;
1395 }
1396
1397 std::string ipAddr = NetConnGetString(STR_LEN);
1398 std::string macAddr = NetConnGetString(STR_LEN);
1399 std::string ifName = NetConnGetString(STR_LEN);
1400 dataParcel.WriteString(ipAddr);
1401 dataParcel.WriteString(macAddr);
1402 dataParcel.WriteString(ifName);
1403 }
1404
StaticIpv6ProcessNoIpAddr(const uint8_t * data,size_t size,MessageParcel & dataParcel)1405 void StaticIpv6ProcessNoIpAddr(const uint8_t *data, size_t size, MessageParcel &dataParcel)
1406 {
1407 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1408 return;
1409 }
1410
1411 std::string macAddr = NetConnGetString(STR_LEN);
1412 std::string ifName = NetConnGetString(STR_LEN);
1413 dataParcel.WriteString(macAddr);
1414 dataParcel.WriteString(ifName);
1415 }
1416
StaticIpv6ProcessNoMacAddr(const uint8_t * data,size_t size,MessageParcel & dataParcel)1417 void StaticIpv6ProcessNoMacAddr(const uint8_t *data, size_t size, MessageParcel &dataParcel)
1418 {
1419 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1420 return;
1421 }
1422
1423 std::string ipAddr = NetConnGetString(STR_LEN);
1424 std::string ifName = NetConnGetString(STR_LEN);
1425 dataParcel.WriteString(ipAddr);
1426 dataParcel.WriteString(ifName);
1427 }
1428
StaticIpv6ProcessNoIfName(const uint8_t * data,size_t size,MessageParcel & dataParcel)1429 void StaticIpv6ProcessNoIfName(const uint8_t *data, size_t size, MessageParcel &dataParcel)
1430 {
1431 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1432 return;
1433 }
1434
1435 std::string ipAddr = NetConnGetString(STR_LEN);
1436 std::string macAddr = NetConnGetString(STR_LEN);
1437 dataParcel.WriteString(ipAddr);
1438 dataParcel.WriteString(macAddr);
1439 }
1440
AddStaticIpv6FuzzTest(const uint8_t * data,size_t size)1441 void AddStaticIpv6FuzzTest(const uint8_t *data, size_t size)
1442 {
1443 MessageParcel dataParcel;
1444 StaticIpv6Process(data, size, dataParcel);
1445 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_STATIC_IPV6), dataParcel);
1446
1447 MessageParcel dataParcelNoIpAddr;
1448 StaticIpv6ProcessNoIpAddr(data, size, dataParcelNoIpAddr);
1449 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_STATIC_IPV6), dataParcelNoIpAddr);
1450
1451 MessageParcel dataParcelNoMacAddr;
1452 StaticIpv6ProcessNoMacAddr(data, size, dataParcelNoMacAddr);
1453 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_STATIC_IPV6), dataParcelNoMacAddr);
1454
1455 MessageParcel dataParcelNoIfName;
1456 StaticIpv6ProcessNoIfName(data, size, dataParcelNoIfName);
1457 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_STATIC_IPV6), dataParcelNoIfName);
1458 }
1459
DelStaticIpv6FuzzTest(const uint8_t * data,size_t size)1460 void DelStaticIpv6FuzzTest(const uint8_t *data, size_t size)
1461 {
1462 MessageParcel dataParcel;
1463 StaticIpv6Process(data, size, dataParcel);
1464 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_DEL_STATIC_IPV6), dataParcel);
1465
1466 MessageParcel dataParcelNoIpAddr;
1467 StaticIpv6ProcessNoIpAddr(data, size, dataParcel);
1468 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_DEL_STATIC_IPV6), dataParcelNoIpAddr);
1469
1470 MessageParcel dataParcelNoMacAddr;
1471 StaticIpv6ProcessNoMacAddr(data, size, dataParcel);
1472 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_DEL_STATIC_IPV6), dataParcelNoMacAddr);
1473
1474 MessageParcel dataParcelNoIfName;
1475 StaticIpv6ProcessNoIfName(data, size, dataParcel);
1476 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_DEL_STATIC_IPV6), dataParcelNoIfName);
1477 }
1478
1479
RegisterSlotTypeFuzzTest(const uint8_t * data,size_t size)1480 void RegisterSlotTypeFuzzTest(const uint8_t *data, size_t size)
1481 {
1482 int32_t supplierId = NetConnGetData<int32_t>();
1483 int32_t type = NetConnGetData<int32_t>();
1484
1485 MessageParcel dataParcel;
1486 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1487 NETMGR_LOG_D("DelInterfaceAddressFuzzTest write token failed or invalid parameter.");
1488 return;
1489 }
1490 dataParcel.WriteInt32(supplierId);
1491 dataParcel.WriteInt32(type);
1492 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_SLOT_TYPE), dataParcel);
1493
1494 MessageParcel dataParcelNoSupplierId;
1495 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoSupplierId)) {
1496 NETMGR_LOG_D("DelInterfaceAddressFuzzTest write token failed or invalid parameter.");
1497 return;
1498 }
1499 dataParcelNoSupplierId.WriteInt32(type);
1500 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_SLOT_TYPE), dataParcelNoSupplierId);
1501
1502 MessageParcel dataParcelNoType;
1503 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoType)) {
1504 NETMGR_LOG_D("DelInterfaceAddressFuzzTest write token failed or invalid parameter.");
1505 return;
1506 }
1507 dataParcel.WriteInt32(supplierId);
1508 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_SLOT_TYPE), dataParcelNoType);
1509 }
1510
GetSlotTypeFuzzTest(const uint8_t * data,size_t size)1511 void GetSlotTypeFuzzTest(const uint8_t *data, size_t size)
1512 {
1513 MessageParcel dataParcel;
1514 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1515 NETMGR_LOG_D("DelInterfaceAddressFuzzTest write token failed or invalid parameter.");
1516 return;
1517 }
1518 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_SLOT_TYPE), dataParcel);
1519 }
1520
IsPreferCellularUrlFuzzTest(const uint8_t * data,size_t size)1521 void IsPreferCellularUrlFuzzTest(const uint8_t *data, size_t size)
1522 {
1523 std::string url = NetConnGetString(STR_LEN);
1524 MessageParcel dataParcel;
1525 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1526 NETMGR_LOG_D("DelInterfaceAddressFuzzTest write token failed or invalid parameter.");
1527 return;
1528 }
1529 dataParcel.WriteString(url);
1530 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_IS_PREFER_CELLULAR_URL), dataParcel);
1531
1532 MessageParcel dataParcelNoUrl;
1533 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoUrl)) {
1534 NETMGR_LOG_D("DelInterfaceAddressFuzzTest write token failed or invalid parameter.");
1535 return;
1536 }
1537 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_IS_PREFER_CELLULAR_URL), dataParcelNoUrl);
1538 }
1539
StaticUpdateSupplierScoreProcess(const uint8_t * data,size_t size,MessageParcel & dataParcel,uint8_t paramsModel)1540 void StaticUpdateSupplierScoreProcess(
1541 const uint8_t *data, size_t size, MessageParcel &dataParcel, uint8_t paramsModel)
1542 {
1543 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1544 return;
1545 }
1546 // ! without the first param.
1547 if (paramsModel != WITHOUT_FIRST_PARM_MODEL) {
1548 int32_t supplierId = NetConnGetData<int32_t>();
1549 dataParcel.WriteInt32(supplierId);
1550 }
1551 // ! without the second param.
1552 if (paramsModel != WITHOUT_SECOND_PARM_MODEL) {
1553 bool isBetter = NetConnGetData<bool>();
1554 dataParcel.WriteBool(isBetter);
1555 }
1556 }
1557
UpdateSupplierScoreFuzzTest(const uint8_t * data,size_t size)1558 void UpdateSupplierScoreFuzzTest(const uint8_t *data, size_t size)
1559 {
1560 MessageParcel dataParcelWithAllParam;
1561 StaticUpdateSupplierScoreProcess(data, size, dataParcelWithAllParam, WITH_ALL_PARM_MODEL);
1562 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UPDATE_SUPPLIER_SCORE), dataParcelWithAllParam);
1563
1564 MessageParcel dataParcelWithOutFirstParam;
1565 StaticUpdateSupplierScoreProcess(data, size, dataParcelWithAllParam, WITHOUT_FIRST_PARM_MODEL);
1566 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UPDATE_SUPPLIER_SCORE),
1567 dataParcelWithOutFirstParam);
1568
1569 MessageParcel dataParcelWithOutSecondParam;
1570 StaticUpdateSupplierScoreProcess(data, size, dataParcelWithAllParam, WITHOUT_SECOND_PARM_MODEL);
1571 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UPDATE_SUPPLIER_SCORE),
1572 dataParcelWithOutSecondParam);
1573 }
1574
StaticDefaultSupplierIdProcess(const uint8_t * data,size_t size,MessageParcel & dataParcel,uint8_t paramsModel)1575 void StaticDefaultSupplierIdProcess(
1576 const uint8_t *data, size_t size, MessageParcel &dataParcel, uint8_t paramsModel)
1577 {
1578 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1579 return;
1580 }
1581 // ! without the first param.
1582 if (paramsModel != WITHOUT_FIRST_PARM_MODEL) {
1583 int32_t type = NetConnGetData<int32_t>();
1584 dataParcel.WriteInt32(type);
1585 }
1586 // ! without the second param.
1587 if (paramsModel != WITHOUT_SECOND_PARM_MODEL) {
1588 std::string ident = NetConnGetString(STR_LEN);
1589 dataParcel.WriteString(ident);
1590 }
1591 // ! without the third param.
1592 if (paramsModel != WITHOUT_THIRD_PARM_MODEL) {
1593 int32_t supplierId = NetConnGetData<int32_t>();
1594 dataParcel.WriteInt32(supplierId);
1595 }
1596 }
1597
GetDefaultSupplierIdFuzzTest(const uint8_t * data,size_t size)1598 void GetDefaultSupplierIdFuzzTest(const uint8_t *data, size_t size)
1599 {
1600 MessageParcel dataParcelWithAllParam;
1601 StaticDefaultSupplierIdProcess(data, size, dataParcelWithAllParam, WITH_ALL_PARM_MODEL);
1602 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_SPECIFIC_SUPPLIER_ID), dataParcelWithAllParam);
1603
1604 MessageParcel dataParcelWithOutFirstParam;
1605 StaticDefaultSupplierIdProcess(data, size, dataParcelWithAllParam, WITHOUT_FIRST_PARM_MODEL);
1606 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_SPECIFIC_SUPPLIER_ID),
1607 dataParcelWithOutFirstParam);
1608
1609 MessageParcel dataParcelWithOutSecondParam;
1610 StaticDefaultSupplierIdProcess(data, size, dataParcelWithAllParam, WITHOUT_SECOND_PARM_MODEL);
1611 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_SPECIFIC_SUPPLIER_ID),
1612 dataParcelWithOutSecondParam);
1613
1614 MessageParcel dataParcelWithOutThirdParam;
1615 StaticDefaultSupplierIdProcess(data, size, dataParcelWithAllParam, WITHOUT_THIRD_PARM_MODEL);
1616 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_SPECIFIC_SUPPLIER_ID),
1617 dataParcelWithOutThirdParam);
1618 }
1619
RegisterPreAirplaneCallbackFuzzTest(const uint8_t * data,size_t size)1620 void RegisterPreAirplaneCallbackFuzzTest(const uint8_t *data, size_t size)
1621 {
1622 NetManagerBaseAccessToken token;
1623 sptr<IPreAirplaneCallbackStubTestCb> callback = new (std::nothrow) IPreAirplaneCallbackStubTestCb();
1624 if (callback == nullptr) {
1625 return;
1626 }
1627
1628 MessageParcel dataParcel;
1629 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1630 return;
1631 }
1632 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_PREAIRPLANE_CALLBACK), dataParcel);
1633
1634 dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
1635
1636 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_PREAIRPLANE_CALLBACK), dataParcel);
1637 }
1638
UnregisterPreAirplaneCallbackFuzzTest(const uint8_t * data,size_t size)1639 void UnregisterPreAirplaneCallbackFuzzTest(const uint8_t *data, size_t size)
1640 {
1641 NetManagerBaseAccessToken token;
1642 sptr<IPreAirplaneCallbackStubTestCb> callback = new (std::nothrow) IPreAirplaneCallbackStubTestCb();
1643 if (callback == nullptr) {
1644 return;
1645 }
1646
1647 MessageParcel dataParcel;
1648 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1649 return;
1650 }
1651 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UNREGISTER_PREAIRPLANE_CALLBACK), dataParcel);
1652
1653 dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
1654
1655 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UNREGISTER_PREAIRPLANE_CALLBACK), dataParcel);
1656 }
1657
EnableDistributedClientNetFuzzTest(const uint8_t * data,size_t size)1658 void EnableDistributedClientNetFuzzTest(const uint8_t *data, size_t size)
1659 {
1660 std::string virnicAddr = NetConnGetString(STR_LEN);
1661 std::string iif = NetConnGetString(STR_LEN);
1662 MessageParcel dataParcel;
1663 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1664 NETMGR_LOG_D("EnableDistributedClientNetFuzzTest write token failed or invalid parameter.");
1665 return;
1666 }
1667 dataParcel.WriteString(virnicAddr);
1668 dataParcel.WriteString(iif);
1669 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ENABLE_DISTRIBUTE_CLIENT_NET), dataParcel);
1670 }
1671
EnableDistributedServerNetFuzzTest(const uint8_t * data,size_t size)1672 void EnableDistributedServerNetFuzzTest(const uint8_t *data, size_t size)
1673 {
1674 std::string iif = NetConnGetString(STR_LEN);
1675 std::string devIface = NetConnGetString(STR_LEN);
1676 std::string dstAddr = NetConnGetString(STR_LEN);
1677
1678 MessageParcel dataParcel;
1679 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1680 NETMGR_LOG_D("EnableDistributedClientNetFuzzTest write token failed or invalid parameter.");
1681 return;
1682 }
1683 dataParcel.WriteString(iif);
1684 dataParcel.WriteString(devIface);
1685 dataParcel.WriteString(dstAddr);
1686 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ENABLE_DISTRIBUTE_SERVER_NET), dataParcel);
1687 }
1688
DisableDistributedNetFuzzTest(const uint8_t * data,size_t size)1689 void DisableDistributedNetFuzzTest(const uint8_t *data, size_t size)
1690 {
1691 bool isServer = NetConnGetData<bool>();
1692 MessageParcel dataParcel;
1693 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1694 NETMGR_LOG_D("EnableDistributedClientNetFuzzTest write token failed or invalid parameter.");
1695 return;
1696 }
1697 dataParcel.WriteBool(isServer);
1698 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_DISABLE_DISTRIBUTE_NET), dataParcel);
1699 }
1700
CloseSocketsUidTest(const uint8_t * data,size_t size)1701 void CloseSocketsUidTest(const uint8_t *data, size_t size)
1702 {
1703 uint32_t uid = NetConnGetData<uint32_t>();
1704 std::string ipAddr = NetConnGetString(STR_LEN);
1705
1706 MessageParcel dataParcel;
1707 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1708 NETMGR_LOG_D("DelInterfaceAddressFuzzTest write token failed or invalid parameter.");
1709 return;
1710 }
1711
1712 dataParcel.WriteString(ipAddr);
1713 dataParcel.WriteUint32(uid);
1714 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_CLOSE_SOCKETS_UID), dataParcel);
1715
1716 MessageParcel dataParcelNoIfName;
1717 if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoIfName)) {
1718 NETMGR_LOG_D("DelInterfaceAddressFuzzTest write token failed or invalid parameter.");
1719 return;
1720 }
1721 dataParcelNoIfName.WriteString(ipAddr);
1722 dataParcelNoIfName.WriteUint32(uid);
1723
1724 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_CLOSE_SOCKETS_UID), dataParcelNoIfName);
1725 }
1726
SetAppIsFrozenedTest(const uint8_t * data,size_t size)1727 void SetAppIsFrozenedTest(const uint8_t *data, size_t size)
1728 {
1729 uint32_t uid = NetConnGetData<uint32_t>();
1730 bool isFrozened = NetConnGetData<bool>();
1731
1732 MessageParcel dataParcel;
1733 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1734 NETMGR_LOG_D("SetAppIsFrozenedTest write token failed or invalid parameter.");
1735 return;
1736 }
1737
1738 dataParcel.WriteUint32(uid);
1739 dataParcel.WriteBool(isFrozened);
1740 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_APP_IS_FROZENED), dataParcel);
1741 }
1742
EnableAppFrozenedCallbackLimitationTest(const uint8_t * data,size_t size)1743 void EnableAppFrozenedCallbackLimitationTest(const uint8_t *data, size_t size)
1744 {
1745 bool flag = NetConnGetData<bool>();
1746
1747 MessageParcel dataParcel;
1748 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1749 NETMGR_LOG_D("EnableAppFrozenedCallbackLimitationTest write token failed or invalid parameter.");
1750 return;
1751 }
1752
1753 dataParcel.WriteBool(flag);
1754 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ENABLE_APP_FROZENED_CALLBACK_LIMITATION),
1755 dataParcel);
1756 }
1757
SetInterfaceUpFuzzTest(const uint8_t * data,size_t size)1758 void SetInterfaceUpFuzzTest(const uint8_t *data, size_t size)
1759 {
1760 NetManagerBaseAccessToken token;
1761 std::string iface = NetConnGetString(STR_LEN);
1762 MessageParcel dataParcel;
1763 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1764 return;
1765 }
1766 dataParcel.WriteString(iface);
1767 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_INTERFACE_UP), dataParcel);
1768 }
1769
SetInterfaceDownFuzzTest(const uint8_t * data,size_t size)1770 void SetInterfaceDownFuzzTest(const uint8_t *data, size_t size)
1771 {
1772 NetManagerBaseAccessToken token;
1773 std::string iface = NetConnGetString(STR_LEN);
1774
1775 MessageParcel dataParcel;
1776 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1777 return;
1778 }
1779
1780 dataParcel.WriteString(iface);
1781 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_INTERFACE_DOWN), dataParcel);
1782 }
1783
SetNetInterfaceIpAddressFuzzTest(const uint8_t * data,size_t size)1784 void SetNetInterfaceIpAddressFuzzTest(const uint8_t *data, size_t size)
1785 {
1786 NetManagerBaseAccessToken token;
1787 std::string iface = NetConnGetString(STR_LEN);
1788 std::string ipAddr = NetConnGetString(STR_LEN);
1789
1790 MessageParcel dataParcel;
1791 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1792 return;
1793 }
1794
1795 dataParcel.WriteString(iface);
1796 dataParcel.WriteString(ipAddr);
1797 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_INTERFACE_IP_ADDRESS), dataParcel);
1798 }
1799
SetPacFileUrlFuzzTest(const uint8_t * data,size_t size)1800 void SetPacFileUrlFuzzTest(const uint8_t *data, size_t size)
1801 {
1802 NetManagerBaseAccessToken token;
1803 MessageParcel dataParcel;
1804 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1805 return;
1806 }
1807 std::string pacUrl = "test.pac";
1808 dataParcel.WriteString(pacUrl);
1809 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_PAC_FILE_URL), dataParcel);
1810 }
1811
SetProxyModeFuzzTest(const uint8_t * data,size_t size)1812 void SetProxyModeFuzzTest(const uint8_t *data, size_t size)
1813 {
1814 NetManagerBaseAccessToken token;
1815 MessageParcel dataParcel;
1816 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1817 return;
1818 }
1819 int mode = 0;
1820 dataParcel.WriteInt32(mode);
1821 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_PROXY_MODE), dataParcel);
1822 }
1823
GetProxyModeFuzzTest(const uint8_t * data,size_t size)1824 void GetProxyModeFuzzTest(const uint8_t *data, size_t size)
1825 {
1826 NetManagerBaseAccessToken token;
1827 MessageParcel dataParcel;
1828 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1829 return;
1830 }
1831 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_PROXY_MODE), dataParcel);
1832 }
1833
GetPacFileUrlFuzzTest(const uint8_t * data,size_t size)1834 void GetPacFileUrlFuzzTest(const uint8_t *data, size_t size)
1835 {
1836 NetManagerBaseAccessToken token;
1837 MessageParcel dataParcel;
1838 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1839 return;
1840 }
1841 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_PAC_FILE_URL), dataParcel);
1842 }
1843
FindProxyForURLFuzzTest(const uint8_t * data,size_t size)1844 void FindProxyForURLFuzzTest(const uint8_t *data, size_t size)
1845 {
1846 NetManagerBaseAccessToken token;
1847 MessageParcel dataParcel;
1848 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1849 return;
1850 }
1851 std::string url = "url";
1852 std::string host = "host";
1853 dataParcel.WriteString(url);
1854 dataParcel.WriteString(host);
1855 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_FIND_PAC_PROXY_FOR_URL), dataParcel);
1856 }
1857
PacFileUrlFuzzTest(const uint8_t * data,size_t size)1858 void PacFileUrlFuzzTest(const uint8_t *data, size_t size)
1859 {
1860 SetPacFileUrlFuzzTest(data, size);
1861 SetProxyModeFuzzTest(data, size);
1862 GetProxyModeFuzzTest(data, size);
1863 GetPacFileUrlFuzzTest(data, size);
1864 FindProxyForURLFuzzTest(data, size);
1865 }
1866
SetReuseSupplierIdFuzzTest(const uint8_t * data,size_t size)1867 void SetReuseSupplierIdFuzzTest(const uint8_t *data, size_t size)
1868 {
1869 uint32_t supplierId = NetConnGetData<uint32_t>();
1870 uint32_t reuseSupplierId = NetConnGetData<uint32_t>();
1871 bool isReused = NetConnGetData<uint32_t>();
1872 MessageParcel dataParcel;
1873 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1874 return;
1875 }
1876 dataParcel.WriteUint32(supplierId);
1877 dataParcel.WriteUint32(reuseSupplierId);
1878 dataParcel.WriteBool(isReused);
1879 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_REUSE_SUPPLIER_ID), dataParcel);
1880 }
1881
RegisterNetFactoryResetCallbackFuzzTest(const uint8_t * data,size_t size)1882 void RegisterNetFactoryResetCallbackFuzzTest(const uint8_t *data, size_t size)
1883 {
1884 MessageParcel dataParcel;
1885 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1886 return;
1887 }
1888 auto callback = sptr<NetFactoryResetCallbackStub>::MakeSptr();
1889 dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
1890 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_FACTORYRESET_CALLBACK), dataParcel);
1891 }
1892
FactoryResetNetworkFuzzTest(const uint8_t * data,size_t size)1893 void FactoryResetNetworkFuzzTest(const uint8_t *data, size_t size)
1894 {
1895 MessageParcel dataParcel;
1896 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1897 return;
1898 }
1899 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_FACTORYRESET_NETWORK), dataParcel);
1900 }
1901
GetIfaceNameIdentMapsFuzzTest(const uint8_t * data,size_t size)1902 void GetIfaceNameIdentMapsFuzzTest(const uint8_t *data, size_t size)
1903 {
1904 MessageParcel dataParcel;
1905 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1906 return;
1907 }
1908 uint32_t netType = NetConnGetData<uint32_t>();
1909 dataParcel.WriteUint32(netType);
1910 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_GET_IFACENAME_IDENT_MAPS), dataParcel);
1911 }
1912
SetQueryTraceRouteFuzzTest(const uint8_t * data,size_t size)1913 void SetQueryTraceRouteFuzzTest(const uint8_t *data, size_t size)
1914 {
1915 NetManagerBaseAccessToken token;
1916 MessageParcel dataParcel;
1917 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1918 return;
1919 }
1920 std::string destination = NetConnGetString(STR_LEN);
1921 int32_t maxJumpNumber = NetConnGetData<int32_t>() % MAX_JUMP_NUMBER;
1922 int32_t packetsType = NetConnGetData<int32_t>() % WITHOUT_SECOND_PARM_MODEL;
1923 dataParcel.WriteString(destination);
1924 dataParcel.WriteInt32(maxJumpNumber);
1925 dataParcel.WriteInt32(packetsType);
1926 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_QUERY_TRACEROUTE), dataParcel);
1927 }
1928
LLVMFuzzerTestOneInputNew(const uint8_t * data,size_t size)1929 void LLVMFuzzerTestOneInputNew(const uint8_t *data, size_t size)
1930 {
1931 OHOS::NetManagerStandard::SetInterfaceUpFuzzTest(data, size);
1932 OHOS::NetManagerStandard::SetInterfaceDownFuzzTest(data, size);
1933 OHOS::NetManagerStandard::SetNetInterfaceIpAddressFuzzTest(data, size);
1934 OHOS::NetManagerStandard::UnregisterNetInterfaceCallbackFuzzTest(data, size);
1935 OHOS::NetManagerStandard::SetAppIsFrozenedTest(data, size);
1936 OHOS::NetManagerStandard::EnableAppFrozenedCallbackLimitationTest(data, size);
1937 OHOS::NetManagerStandard::GetSpecificNetByIdentFuzzTest(data, size);
1938 OHOS::NetManagerStandard::SetQueryTraceRouteFuzzTest(data, size);
1939 }
1940 } // namespace NetManagerStandard
1941 } // namespace OHOS
1942
1943 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)1944 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
1945 {
1946 /* Run your code on data */
1947 OHOS::NetManagerStandard::SystemReadyFuzzTest(data, size);
1948 OHOS::NetManagerStandard::RegisterNetSupplierFuzzTest(data, size);
1949 OHOS::NetManagerStandard::UnregisterNetSupplierFuzzTest(data, size);
1950 OHOS::NetManagerStandard::RegisterNetSupplierCallbackFuzzTest(data, size);
1951 OHOS::NetManagerStandard::UpdateNetSupplierInfoFuzzTest(data, size);
1952 OHOS::NetManagerStandard::UpdateNetLinkInfoFuzzTest(data, size);
1953 OHOS::NetManagerStandard::RegisterNetConnCallbackBySpecifierFuzzTest(data, size);
1954 OHOS::NetManagerStandard::RegisterNetConnCallbackFuzzTest(data, size);
1955 OHOS::NetManagerStandard::UnregisterNetConnCallbackFuzzTest(data, size);
1956 OHOS::NetManagerStandard::GetDefaultNetFuzzTest(data, size);
1957 OHOS::NetManagerStandard::HasDefaultNetFuzzTest(data, size);
1958 OHOS::NetManagerStandard::GetAllNetsFuzzTest(data, size);
1959 OHOS::NetManagerStandard::GetConnectionPropertiesFuzzTest(data, size);
1960 OHOS::NetManagerStandard::GetNetCapabilitiesFuzzTest(data, size);
1961 OHOS::NetManagerStandard::GetAddressesByNameFuzzTest(data, size);
1962 OHOS::NetManagerStandard::GetAddressByNameFuzzTest(data, size);
1963 OHOS::NetManagerStandard::BindSocketFuzzTest(data, size);
1964 OHOS::NetManagerStandard::NetDetectionFuzzTest(data, size);
1965 OHOS::NetManagerStandard::SetAirplaneModeFuzzTest(data, size);
1966 OHOS::NetManagerStandard::IsDefaultNetMeteredFuzzTest(data, size);
1967 OHOS::NetManagerStandard::SetGlobalHttpProxyFuzzTest(data, size);
1968 OHOS::NetManagerStandard::GetGlobalHttpProxyFuzzTest(data, size);
1969 OHOS::NetManagerStandard::GetDefaultHttpProxyFuzzTest(data, size);
1970 OHOS::NetManagerStandard::SetAppHttpProxyFuzzTest(data, size);
1971 OHOS::NetManagerStandard::RegisterAppHttpProxyCallbackFuzzTest(data, size);
1972 OHOS::NetManagerStandard::UnregisterAppHttpProxyCallbackFuzzTest(data, size);
1973 OHOS::NetManagerStandard::GetNetIdByIdentifierFuzzTest(data, size);
1974 OHOS::NetManagerStandard::RegisterNetInterfaceCallbackFuzzTest(data, size);
1975 OHOS::NetManagerStandard::GetNetInterfaceConfigurationFuzzTest(data, size);
1976 OHOS::NetManagerStandard::SetInternetPermissionFuzzTest(data, size);
1977 OHOS::NetManagerStandard::UpdateNetStateForTestFuzzTest(data, size);
1978 OHOS::NetManagerStandard::GetIfaceNamesFuzzTest(data, size);
1979 OHOS::NetManagerStandard::GetIfaceNameByTypeFuzzTest(data, size);
1980 OHOS::NetManagerStandard::RegisterNetDetectionCallbackFuzzTest(data, size);
1981 OHOS::NetManagerStandard::UnRegisterNetDetectionCallbackFuzzTest(data, size);
1982 OHOS::NetManagerStandard::GetSpecificNetFuzzTest(data, size);
1983 OHOS::NetManagerStandard::GetSpecificUidNetFuzzTest(data, size);
1984 OHOS::NetManagerStandard::OnSetAppNetFuzzTest(data, size);
1985 OHOS::NetManagerStandard::AddNetworkRouteFuzzTest(data, size);
1986 OHOS::NetManagerStandard::RemoveNetworkRouteFuzzTest(data, size);
1987 OHOS::NetManagerStandard::AddInterfaceAddressFuzzTest(data, size);
1988 OHOS::NetManagerStandard::DelInterfaceAddressFuzzTest(data, size);
1989 OHOS::NetManagerStandard::AddStaticArpFuzzTest(data, size);
1990 OHOS::NetManagerStandard::DelStaticArpFuzzTest(data, size);
1991 OHOS::NetManagerStandard::EnableDistributedClientNetFuzzTest(data, size);
1992 OHOS::NetManagerStandard::EnableDistributedServerNetFuzzTest(data, size);
1993 OHOS::NetManagerStandard::DisableDistributedNetFuzzTest(data, size);
1994 OHOS::NetManagerStandard::CloseSocketsUidTest(data, size);
1995 OHOS::NetManagerStandard::SetReuseSupplierIdFuzzTest(data, size);
1996 OHOS::NetManagerStandard::LLVMFuzzerTestOneInputNew(data, size);
1997 OHOS::NetManagerStandard::UpdateSupplierScoreFuzzTest(data, size);
1998 OHOS::NetManagerStandard::SetNetExtAttributeFuzzTest(data, size);
1999 OHOS::NetManagerStandard::GetNetExtAttributeFuzzTest(data, size);
2000 OHOS::NetManagerStandard::UnregisterPreAirplaneCallbackFuzzTest(data, size);
2001 OHOS::NetManagerStandard::RegisterPreAirplaneCallbackFuzzTest(data, size);
2002 OHOS::NetManagerStandard::GetDefaultSupplierIdFuzzTest(data, size);
2003 OHOS::NetManagerStandard::IsPreferCellularUrlFuzzTest(data, size);
2004 OHOS::NetManagerStandard::GetSlotTypeFuzzTest(data, size);
2005 OHOS::NetManagerStandard::RegisterSlotTypeFuzzTest(data, size);
2006 OHOS::NetManagerStandard::RegisterNetFactoryResetCallbackFuzzTest(data, size);
2007 OHOS::NetManagerStandard::FactoryResetNetworkFuzzTest(data, size);
2008 OHOS::NetManagerStandard::GetIfaceNameIdentMapsFuzzTest(data, size);
2009 OHOS::NetManagerStandard::AddStaticIpv6FuzzTest(data, size);
2010 OHOS::NetManagerStandard::DelStaticIpv6FuzzTest(data, size);
2011 OHOS::NetManagerStandard::PacFileUrlFuzzTest(data, size);
2012 return 0;
2013 }
2014