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 
33 namespace OHOS {
34 namespace NetManagerStandard {
35 namespace {
36 const uint8_t *g_baseFuzzData = nullptr;
37 static constexpr uint32_t CREATE_NET_TYPE_VALUE = 7;
38 static constexpr uint8_t WITH_ALL_PARM_MODEL = 0;
39 static constexpr uint8_t WITHOUT_FIRST_PARM_MODEL = 1;
40 static constexpr uint8_t WITHOUT_SECOND_PARM_MODEL = 2;
41 static constexpr uint8_t WITHOUT_THIRD_PARM_MODEL = 3;
42 size_t g_baseFuzzSize = 0;
43 size_t g_baseFuzzPos;
44 constexpr size_t STR_LEN = 10;
45 } // namespace
46 
NetConnGetData()47 template <class T> T NetConnGetData()
48 {
49     T object{};
50     size_t netConnSize = sizeof(object);
51     if (g_baseFuzzData == nullptr || netConnSize > g_baseFuzzSize - g_baseFuzzPos) {
52         return object;
53     }
54     errno_t ret = memcpy_s(&object, netConnSize, g_baseFuzzData + g_baseFuzzPos, netConnSize);
55     if (ret != EOK) {
56         return {};
57     }
58     g_baseFuzzPos += netConnSize;
59     return object;
60 }
61 
NetConnGetString(int strlen)62 std::string NetConnGetString(int strlen)
63 {
64     char cstr[strlen];
65     cstr[strlen - 1] = '\0';
66     for (int i = 0; i < strlen - 1; i++) {
67         cstr[i] = NetConnGetData<char>();
68     }
69     std::string str(cstr);
70     return str;
71 }
72 
GetSecureDataFromData(int8_t strlen)73 SecureData GetSecureDataFromData(int8_t strlen)
74 {
75     SecureData secureData;
76     char cstr[strlen];
77     cstr[strlen - 1] = '\0';
78     for (int i = 0; i < strlen - 1; i++) {
79         cstr[i] = NetConnGetData<char>();
80     }
81     secureData.append(cstr, strlen-1);
82     return secureData;
83 }
84 
85 class INetDetectionCallbackTest : public IRemoteStub<INetDetectionCallback> {
86 public:
OnNetDetectionResultChanged(NetDetectionResultCode detectionResult,const std::string & urlRedirect)87     virtual int32_t OnNetDetectionResultChanged(NetDetectionResultCode detectionResult, const std::string &urlRedirect)
88     {
89         return 0;
90     }
91 };
92 
93 class NetInterfaceStateCallbackTest : public NetInterfaceStateCallbackStub {};
94 
95 static bool g_isInited = false;
Init()96 void Init()
97 {
98     if (!g_isInited) {
99         if (!DelayedSingleton<NetConnService>::GetInstance()->Init()) {
100             g_isInited = false;
101         } else {
102             g_isInited = true;
103         }
104     }
105 }
106 
OnRemoteRequest(uint32_t code,MessageParcel & data)107 int32_t OnRemoteRequest(uint32_t code, MessageParcel &data)
108 {
109     if (!g_isInited) {
110         NETMGR_LOG_D("Net conn client fuzz test g_isInited is false.");
111         Init();
112     }
113 
114     MessageParcel reply;
115     MessageOption option;
116 
117     int32_t ret = DelayedSingleton<NetConnService>::GetInstance()->OnRemoteRequest(code, data, reply, option);
118     return ret;
119 }
120 
WriteInterfaceToken(MessageParcel & data)121 bool WriteInterfaceToken(MessageParcel &data)
122 {
123     if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
124         NETMGR_LOG_D("Write token failed.");
125         return false;
126     }
127     return true;
128 }
129 
IsConnClientDataAndSizeValid(const uint8_t * data,size_t size,MessageParcel & dataParcel)130 bool IsConnClientDataAndSizeValid(const uint8_t *data, size_t size, MessageParcel &dataParcel)
131 {
132     g_baseFuzzData = data;
133     g_baseFuzzSize = size;
134     g_baseFuzzPos = 0;
135 
136     if (!WriteInterfaceToken(dataParcel)) {
137         return false;
138     }
139     return true;
140 }
141 
SetAppHttpProxyCallback(const HttpProxy & httpProxy)142 void SetAppHttpProxyCallback(const HttpProxy &httpProxy)
143 {
144     return;
145 }
146 
SystemReadyFuzzTest(const uint8_t * data,size_t size)147 void SystemReadyFuzzTest(const uint8_t *data, size_t size)
148 {
149     NetManagerBaseAccessToken token;
150 
151     MessageParcel dataParcel;
152     if (!WriteInterfaceToken(dataParcel)) {
153         return;
154     }
155     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SYSTEM_READY), dataParcel);
156 }
157 
RegisterNetSupplierFuzzTest(const uint8_t * data,size_t size)158 void RegisterNetSupplierFuzzTest(const uint8_t *data, size_t size)
159 {
160     NetManagerBaseAccessToken token;
161     MessageParcel dataParcel;
162     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
163         return;
164     }
165     uint32_t bearerType = NetConnGetData<uint32_t>() % CREATE_NET_TYPE_VALUE;
166     dataParcel.WriteUint32(bearerType);
167 
168     std::string ident = NetConnGetString(STR_LEN);
169     dataParcel.WriteString(ident);
170 
171     std::set<NetCap> netCaps{NET_CAPABILITY_INTERNET, NET_CAPABILITY_MMS};
172     uint32_t capsSize = static_cast<uint32_t>(netCaps.size());
173     dataParcel.WriteUint32(capsSize);
174     for (auto netCap : netCaps) {
175         dataParcel.WriteUint32(static_cast<uint32_t>(netCap));
176     }
177 
178     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REG_NET_SUPPLIER), dataParcel);
179 }
180 
UnregisterNetSupplierFuzzTest(const uint8_t * data,size_t size)181 void UnregisterNetSupplierFuzzTest(const uint8_t *data, size_t size)
182 {
183     NetManagerBaseAccessToken token;
184     uint32_t supplierId = NetConnGetData<uint32_t>();
185     MessageParcel dataParcel;
186     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
187         return;
188     }
189     dataParcel.WriteUint32(supplierId);
190     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UNREG_NETWORK), dataParcel);
191 }
192 
HasDefaultNetFuzzTest(const uint8_t * data,size_t size)193 void HasDefaultNetFuzzTest(const uint8_t *data, size_t size)
194 {
195     NetManagerBaseAccessToken token;
196 
197     MessageParcel dataParcel;
198     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
199         return;
200     }
201 
202     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_HASDEFAULTNET), dataParcel);
203 }
204 
GetAllNetsFuzzTest(const uint8_t * data,size_t size)205 void GetAllNetsFuzzTest(const uint8_t *data, size_t size)
206 {
207     if ((data == nullptr) || (size == 0)) {
208         return;
209     }
210     NetManagerBaseAccessToken token;
211 
212     MessageParcel dataParcel;
213     if (!WriteInterfaceToken(dataParcel)) {
214         return;
215     }
216 
217     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_ALL_NETS), dataParcel);
218 }
219 
BindSocketFuzzTest(const uint8_t * data,size_t size)220 void BindSocketFuzzTest(const uint8_t *data, size_t size)
221 {
222     NetManagerBaseAccessToken token;
223     int32_t socketFd = NetConnGetData<int32_t>();
224     int32_t netId = NetConnGetData<int32_t>();
225     MessageParcel dataParcel;
226     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
227         return;
228     }
229     dataParcel.WriteInt32(socketFd);
230     dataParcel.WriteInt32(netId);
231     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_BIND_SOCKET), dataParcel);
232 }
233 
SetAirplaneModeFuzzTest(const uint8_t * data,size_t size)234 void SetAirplaneModeFuzzTest(const uint8_t *data, size_t size)
235 {
236     NetManagerBaseAccessToken token;
237     bool state = NetConnGetData<bool>();
238 
239     MessageParcel dataParcel;
240     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
241         return;
242     }
243     dataParcel.WriteBool(state);
244     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_AIRPLANE_MODE), dataParcel);
245 
246     MessageParcel dataParcelNoState;
247     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoState)) {
248         return;
249     }
250 
251     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_AIRPLANE_MODE), dataParcelNoState);
252 }
253 
UpdateNetSupplierInfoFuzzTest(const uint8_t * data,size_t size)254 void UpdateNetSupplierInfoFuzzTest(const uint8_t *data, size_t size)
255 {
256     NetManagerBaseAccessToken token;
257     uint32_t supplierId = NetConnGetData<uint32_t>();
258     sptr<NetSupplierInfo> netSupplierInfo = new (std::nothrow) NetSupplierInfo();
259 
260     MessageParcel dataParcel;
261     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
262         NETMGR_LOG_D("UpdateNetSupplierInfoFuzzTest write token failed or invalid parameter.");
263         return;
264     }
265     dataParcel.WriteUint32(supplierId);
266     netSupplierInfo->Marshalling(dataParcel);
267     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_NET_SUPPLIER_INFO), dataParcel);
268 
269     MessageParcel dataParcelNoSupplierId;
270     netSupplierInfo->Marshalling(dataParcel);
271     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_NET_SUPPLIER_INFO), dataParcel);
272 }
273 
GetAddressByNameFuzzTest(const uint8_t * data,size_t size)274 void GetAddressByNameFuzzTest(const uint8_t *data, size_t size)
275 {
276     NetManagerBaseAccessToken token;
277     std::string host = NetConnGetString(STR_LEN);
278     int32_t netId = NetConnGetData<int32_t>();
279 
280     MessageParcel dataParcel;
281     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
282         NETMGR_LOG_D("GetAddressByNameFuzzTest write token failed or invalid parameter.");
283         return;
284     }
285     dataParcel.WriteString(host);
286     dataParcel.WriteInt32(netId);
287 
288     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_ADDRESS_BY_NAME), dataParcel);
289 
290     MessageParcel dataParcelNoHost;
291     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoHost)) {
292         NETMGR_LOG_D("GetAddressByNameFuzzTest write token failed or invalid parameter.");
293         return;
294     }
295     dataParcelNoHost.WriteInt32(netId);
296 
297     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_ADDRESS_BY_NAME), dataParcelNoHost);
298 
299     MessageParcel dataParcelNoNetId;
300     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetId)) {
301         NETMGR_LOG_D("GetAddressByNameFuzzTest write token failed or invalid parameter.");
302         return;
303     }
304     dataParcelNoNetId.WriteInt32(netId);
305 
306     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_ADDRESS_BY_NAME), dataParcelNoNetId);
307 }
308 
GetAddressesByNameFuzzTest(const uint8_t * data,size_t size)309 void GetAddressesByNameFuzzTest(const uint8_t *data, size_t size)
310 {
311     NetManagerBaseAccessToken token;
312     std::string host = NetConnGetString(STR_LEN);
313     int32_t netId = NetConnGetData<int32_t>();
314 
315     MessageParcel dataParcel;
316     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
317         return;
318     }
319     dataParcel.WriteString(host);
320     dataParcel.WriteInt32(netId);
321 
322     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_ADDRESSES_BY_NAME), dataParcel);
323 
324     MessageParcel dataParcelNoHost;
325     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoHost)) {
326         return;
327     }
328     dataParcelNoHost.WriteInt32(netId);
329 
330     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_ADDRESSES_BY_NAME), dataParcelNoHost);
331 
332     MessageParcel dataParcelNoNetId;
333     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetId)) {
334         return;
335     }
336     dataParcelNoNetId.WriteString(host);
337 
338     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_ADDRESSES_BY_NAME), dataParcelNoNetId);
339 }
340 
UpdateNetLinkInfoFuzzTest(const uint8_t * data,size_t size)341 void UpdateNetLinkInfoFuzzTest(const uint8_t *data, size_t size)
342 {
343     uint32_t supplierId = NetConnGetData<uint32_t>();
344     sptr<NetLinkInfo> netLinkInfo = new (std::nothrow) NetLinkInfo();
345     if (netLinkInfo == nullptr) {
346         return;
347     }
348 
349     MessageParcel dataParcel;
350     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
351         return;
352     }
353     dataParcel.WriteUint32(supplierId);
354     netLinkInfo->Marshalling(dataParcel);
355 
356     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_NET_LINK_INFO), dataParcel);
357 
358     MessageParcel dataParcelNoSupplierId;
359     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoSupplierId)) {
360         return;
361     }
362     netLinkInfo->Marshalling(dataParcelNoSupplierId);
363 
364     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_NET_LINK_INFO), dataParcelNoSupplierId);
365 }
366 
RegisterNetSupplierCallbackFuzzTest(const uint8_t * data,size_t size)367 void RegisterNetSupplierCallbackFuzzTest(const uint8_t *data, size_t size)
368 {
369     NetManagerBaseAccessToken token;
370     uint32_t supplierId = NetConnGetData<uint32_t>();
371     sptr<NetSupplierCallbackStubTestCb> callback = new (std::nothrow) NetSupplierCallbackStubTestCb();
372     if (callback == nullptr) {
373         return;
374     }
375 
376     MessageParcel dataParcel;
377     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
378         return;
379     }
380     dataParcel.WriteUint32(supplierId);
381     dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
382 
383     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_SUPPLIER_CALLBACK), dataParcel);
384 
385     MessageParcel dataParcelNoSupplierId;
386     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
387         return;
388     }
389     dataParcelNoSupplierId.WriteRemoteObject(callback->AsObject().GetRefPtr());
390 
391     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_SUPPLIER_CALLBACK),
392                     dataParcelNoSupplierId);
393 
394     MessageParcel dataParcelNoRemoteObject;
395     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoRemoteObject)) {
396         return;
397     }
398     dataParcelNoRemoteObject.WriteUint32(supplierId);
399 
400     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_SUPPLIER_CALLBACK),
401                     dataParcelNoRemoteObject);
402 }
403 
RegisterNetConnCallbackBySpecifierFuzzTest(const uint8_t * data,size_t size)404 void RegisterNetConnCallbackBySpecifierFuzzTest(const uint8_t *data, size_t size)
405 {
406     NetManagerBaseAccessToken token;
407     sptr<NetSpecifier> netSpecifier = new (std::nothrow) NetSpecifier();
408     sptr<INetConnCallbackTest> callback = new (std::nothrow) INetConnCallbackTest();
409     if (netSpecifier == nullptr || callback == nullptr) {
410         return;
411     }
412     uint32_t timeoutMS = NetConnGetData<uint32_t>();
413 
414     MessageParcel dataParcel;
415     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
416         return;
417     }
418     netSpecifier->Marshalling(dataParcel);
419     dataParcel.WriteUint32(timeoutMS);
420     dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
421 
422     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_CONN_CALLBACK_BY_SPECIFIER),
423                     dataParcel);
424 
425     MessageParcel dataParcelNoNetSpecifier;
426     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetSpecifier)) {
427         return;
428     }
429     netSpecifier->Marshalling(dataParcelNoNetSpecifier);
430     dataParcelNoNetSpecifier.WriteRemoteObject(callback->AsObject().GetRefPtr());
431 
432     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_CONN_CALLBACK_BY_SPECIFIER),
433                     dataParcelNoNetSpecifier);
434 
435     MessageParcel dataParcelNoRemoteObject;
436     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoRemoteObject)) {
437         return;
438     }
439     netSpecifier->Marshalling(dataParcelNoRemoteObject);
440     dataParcelNoRemoteObject.WriteUint32(timeoutMS);
441 
442     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_CONN_CALLBACK_BY_SPECIFIER),
443                     dataParcelNoRemoteObject);
444 }
445 
RegisterNetConnCallbackFuzzTest(const uint8_t * data,size_t size)446 void RegisterNetConnCallbackFuzzTest(const uint8_t *data, size_t size)
447 {
448     sptr<INetConnCallbackTest> callback = new (std::nothrow) INetConnCallbackTest();
449     if (callback == nullptr) {
450         return;
451     }
452 
453     MessageParcel dataParcel;
454     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
455         return;
456     }
457 
458     dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
459 
460     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_CONN_CALLBACK), dataParcel);
461 
462     MessageParcel dataParcelNoRemoteObject;
463     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoRemoteObject)) {
464         return;
465     }
466 
467     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_CONN_CALLBACK),
468                     dataParcelNoRemoteObject);
469 }
470 
UnregisterNetConnCallbackFuzzTest(const uint8_t * data,size_t size)471 void UnregisterNetConnCallbackFuzzTest(const uint8_t *data, size_t size)
472 {
473     if ((data == nullptr) || (size == 0)) {
474         return;
475     }
476 
477     NetManagerBaseAccessToken token;
478     sptr<INetConnCallbackTest> callback = new (std::nothrow) INetConnCallbackTest();
479     if (callback == nullptr) {
480         return;
481     }
482 
483     MessageParcel dataParcel;
484     if (!WriteInterfaceToken(dataParcel)) {
485         return;
486     }
487     dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
488 
489     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UNREGISTER_NET_CONN_CALLBACK), dataParcel);
490 
491     MessageParcel dataParcelNoRemoteObject;
492     if (!WriteInterfaceToken(dataParcelNoRemoteObject)) {
493         return;
494     }
495 
496     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UNREGISTER_NET_CONN_CALLBACK),
497                     dataParcelNoRemoteObject);
498 }
499 
GetDefaultNetFuzzTest(const uint8_t * data,size_t size)500 void GetDefaultNetFuzzTest(const uint8_t *data, size_t size)
501 {
502     NetManagerBaseAccessToken token;
503 
504     MessageParcel dataParcel;
505     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
506         return;
507     }
508     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GETDEFAULTNETWORK), dataParcel);
509 }
510 
GetConnectionPropertiesFuzzTest(const uint8_t * data,size_t size)511 void GetConnectionPropertiesFuzzTest(const uint8_t *data, size_t size)
512 {
513     NetManagerBaseAccessToken token;
514     int32_t netId = NetConnGetData<int32_t>();
515 
516     MessageParcel dataParcel;
517     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
518         return;
519     }
520     dataParcel.WriteInt32(netId);
521     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_CONNECTION_PROPERTIES), dataParcel);
522 
523     MessageParcel dataParcelNoNetId;
524     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetId)) {
525         return;
526     }
527     dataParcelNoNetId.WriteInt32(netId);
528     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_CONNECTION_PROPERTIES), dataParcelNoNetId);
529 }
530 
GetNetCapabilitiesFuzzTest(const uint8_t * data,size_t size)531 void GetNetCapabilitiesFuzzTest(const uint8_t *data, size_t size)
532 {
533     NetManagerBaseAccessToken token;
534     int32_t netId = NetConnGetData<int32_t>();
535 
536     MessageParcel dataParcel;
537     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
538         return;
539     }
540     dataParcel.WriteInt32(netId);
541     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_NET_CAPABILITIES), dataParcel);
542 
543     MessageParcel dataParcelNoNetId;
544     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetId)) {
545         return;
546     }
547     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_NET_CAPABILITIES), dataParcelNoNetId);
548 }
549 
NetDetectionFuzzTest(const uint8_t * data,size_t size)550 void NetDetectionFuzzTest(const uint8_t *data, size_t size)
551 {
552     NetManagerBaseAccessToken tokenInternetInfo;
553     int32_t netId = NetConnGetData<int32_t>();
554 
555     MessageParcel dataParcel;
556     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
557         return;
558     }
559     dataParcel.WriteInt32(netId);
560     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_NET_DETECTION), dataParcel);
561 
562     MessageParcel dataParcelNoNetId;
563     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetId)) {
564         return;
565     }
566     dataParcelNoNetId.WriteInt32(netId);
567     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_NET_DETECTION), dataParcelNoNetId);
568 }
569 
IsDefaultNetMeteredFuzzTest(const uint8_t * data,size_t size)570 void IsDefaultNetMeteredFuzzTest(const uint8_t *data, size_t size)
571 {
572     NetManagerBaseAccessToken token;
573 
574     MessageParcel dataParcel;
575     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
576         return;
577     }
578     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_IS_DEFAULT_NET_METERED), dataParcel);
579 }
580 
581 
SetAppHttpProxyFuzzTest(const uint8_t * data,size_t size)582 void SetAppHttpProxyFuzzTest(const uint8_t *data, size_t size)
583 {
584     HttpProxy httpProxy = {NetConnGetString(STR_LEN), 0, {}};
585     DelayedSingleton<NetConnClient>::GetInstance()->SetAppHttpProxy(httpProxy);
586 }
587 
RegisterAppHttpProxyCallbackFuzzTest(const uint8_t * data,size_t size)588 void RegisterAppHttpProxyCallbackFuzzTest(const uint8_t *data, size_t size)
589 {
590     uint32_t callbackId = 0;
591     DelayedSingleton<NetConnClient>::GetInstance()->RegisterAppHttpProxyCallback(SetAppHttpProxyCallback, callbackId);
592 }
593 
UnregisterAppHttpProxyCallbackFuzzTest(const uint8_t * data,size_t size)594 void UnregisterAppHttpProxyCallbackFuzzTest(const uint8_t *data, size_t size)
595 {
596     int32_t callbackId = NetConnGetData<int32_t>();
597     DelayedSingleton<NetConnClient>::GetInstance()->UnregisterAppHttpProxyCallback(callbackId);
598 }
599 
SetGlobalHttpProxyFuzzTest(const uint8_t * data,size_t size)600 void SetGlobalHttpProxyFuzzTest(const uint8_t *data, size_t size)
601 {
602     NetManagerBaseAccessToken token;
603     HttpProxy httpProxy = {NetConnGetString(STR_LEN), 0, {}};
604     httpProxy.SetUserName(GetSecureDataFromData(STR_LEN));
605     httpProxy.SetPassword(GetSecureDataFromData(STR_LEN));
606     MessageParcel dataParcel;
607     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
608         return;
609     }
610     httpProxy.Marshalling(dataParcel);
611     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_GLOBAL_HTTP_PROXY), dataParcel);
612 }
613 
GetGlobalHttpProxyFuzzTest(const uint8_t * data,size_t size)614 void GetGlobalHttpProxyFuzzTest(const uint8_t *data, size_t size)
615 {
616     NetManagerBaseAccessToken token;
617 
618     MessageParcel dataParcel;
619     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
620         return;
621     }
622     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_GLOBAL_HTTP_PROXY), dataParcel);
623 }
624 
GetDefaultHttpProxyFuzzTest(const uint8_t * data,size_t size)625 void GetDefaultHttpProxyFuzzTest(const uint8_t *data, size_t size)
626 {
627     NetManagerBaseAccessToken token;
628 
629     MessageParcel dataParcel;
630     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
631         return;
632     }
633     int32_t bindNetId = NetConnGetData<int32_t>();
634     dataParcel.WriteInt32(bindNetId);
635     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_DEFAULT_HTTP_PROXY), dataParcel);
636 }
637 
GetNetIdByIdentifierFuzzTest(const uint8_t * data,size_t size)638 void GetNetIdByIdentifierFuzzTest(const uint8_t *data, size_t size)
639 {
640     NetManagerBaseAccessToken token;
641     std::string ident = NetConnGetString(STR_LEN);
642 
643     MessageParcel dataParcel;
644     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
645         return;
646     }
647     dataParcel.WriteString(ident);
648     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_NET_ID_BY_IDENTIFIER), dataParcel);
649 
650     MessageParcel dataParcelNoIdent;
651     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoIdent)) {
652         return;
653     }
654     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_NET_ID_BY_IDENTIFIER), dataParcelNoIdent);
655 }
656 
RegisterNetInterfaceCallbackFuzzTest(const uint8_t * data,size_t size)657 void RegisterNetInterfaceCallbackFuzzTest(const uint8_t *data, size_t size)
658 {
659     if ((data == nullptr) || (size == 0)) {
660         return;
661     }
662 
663     NetManagerBaseAccessToken token;
664     sptr<INetInterfaceStateCallback> callback = new (std::nothrow) NetInterfaceStateCallbackTest();
665     if (callback == nullptr) {
666         return;
667     }
668 
669     MessageParcel dataParcel;
670     if (!WriteInterfaceToken(dataParcel)) {
671         return;
672     }
673     dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
674     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_INTERFACE_CALLBACK), dataParcel);
675 
676     MessageParcel dataParcelNoRemoteObject;
677     if (!WriteInterfaceToken(dataParcelNoRemoteObject)) {
678         return;
679     }
680     dataParcelNoRemoteObject.WriteRemoteObject(callback->AsObject().GetRefPtr());
681     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_INTERFACE_CALLBACK),
682                     dataParcelNoRemoteObject);
683 }
684 
GetNetInterfaceConfigurationFuzzTest(const uint8_t * data,size_t size)685 void GetNetInterfaceConfigurationFuzzTest(const uint8_t *data, size_t size)
686 {
687     NetManagerBaseAccessToken token;
688     std::string iface = NetConnGetString(STR_LEN);
689 
690     MessageParcel dataParcel;
691     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
692         return;
693     }
694     dataParcel.WriteString(iface);
695     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_INTERFACE_CONFIGURATION), dataParcel);
696 
697     MessageParcel dataParcelNoIface;
698     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoIface)) {
699         return;
700     }
701     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_INTERFACE_CONFIGURATION), dataParcelNoIface);
702 }
703 
SetInternetPermissionFuzzTest(const uint8_t * data,size_t size)704 void SetInternetPermissionFuzzTest(const uint8_t *data, size_t size)
705 {
706     uint32_t uid = NetConnGetData<uint32_t>();
707     uint8_t allow = NetConnGetData<uint8_t>();
708 
709     NetManagerBaseAccessToken token;
710     MessageParcel dataParcel;
711     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
712         return;
713     }
714 
715     dataParcel.WriteUint32(uid);
716     dataParcel.WriteUint8(allow);
717     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_INTERNET_PERMISSION), dataParcel);
718 
719     MessageParcel dataParcelNoUid;
720     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoUid)) {
721         return;
722     }
723 
724     dataParcelNoUid.WriteUint8(allow);
725     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_INTERNET_PERMISSION), dataParcelNoUid);
726 
727     MessageParcel dataParcelNoAllow;
728     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoAllow)) {
729         return;
730     }
731 
732     dataParcel.WriteUint32(uid);
733     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_INTERNET_PERMISSION), dataParcelNoAllow);
734 }
735 
UpdateNetStateForTestFuzzTest(const uint8_t * data,size_t size)736 void UpdateNetStateForTestFuzzTest(const uint8_t *data, size_t size)
737 {
738     sptr<NetSpecifier> netSpecifier = new (std::nothrow) NetSpecifier();
739     if (netSpecifier == nullptr) {
740         return;
741     }
742     auto netState = NetConnGetData<int32_t>();
743 
744     MessageParcel dataParcel;
745     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
746         NETMGR_LOG_D("UpdateNetSupplierInfoFuzzTest write token failed or invalid parameter.");
747         return;
748     }
749 
750     netSpecifier->Marshalling(dataParcel);
751     dataParcel.WriteInt32(netState);
752     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UPDATE_NET_STATE_FOR_TEST), dataParcel);
753 
754     MessageParcel dataParcelNoNetState;
755     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetState)) {
756         NETMGR_LOG_D("UpdateNetSupplierInfoFuzzTest write token failed or invalid parameter.");
757         return;
758     }
759 
760     netSpecifier->Marshalling(dataParcelNoNetState);
761     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UPDATE_NET_STATE_FOR_TEST), dataParcelNoNetState);
762 }
763 
GetIfaceNamesFuzzTest(const uint8_t * data,size_t size)764 void GetIfaceNamesFuzzTest(const uint8_t *data, size_t size)
765 {
766     uint32_t bearerType = NetConnGetData<uint32_t>() % CREATE_NET_TYPE_VALUE;
767 
768     MessageParcel dataParcel;
769     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
770         NETMGR_LOG_D("GetIfaceNamesFuzzTest write token failed or invalid parameter.");
771         return;
772     }
773 
774     dataParcel.WriteUint32(bearerType);
775 
776     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_IFACE_NAMES), dataParcel);
777 
778     MessageParcel dataParcelNoBearerType;
779     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoBearerType)) {
780         NETMGR_LOG_D("GetIfaceNamesFuzzTest write token failed or invalid parameter.");
781         return;
782     }
783 
784     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_IFACE_NAMES), dataParcelNoBearerType);
785 }
786 
GetIfaceNameByTypeFuzzTest(const uint8_t * data,size_t size)787 void GetIfaceNameByTypeFuzzTest(const uint8_t *data, size_t size)
788 {
789     uint32_t bearerType = NetConnGetData<uint32_t>() % CREATE_NET_TYPE_VALUE;
790     std::string ident = NetConnGetString(STR_LEN);
791 
792     MessageParcel dataParcel;
793     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
794         NETMGR_LOG_D("GetIfaceNameByTypeFuzzTest write token failed or invalid parameter.");
795         return;
796     }
797 
798     dataParcel.WriteUint32(bearerType);
799     dataParcel.WriteString(ident);
800 
801     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_IFACENAME_BY_TYPE), dataParcel);
802 
803     MessageParcel dataParcelNoBearerType;
804     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoBearerType)) {
805         NETMGR_LOG_D("GetIfaceNameByTypeFuzzTest write token failed or invalid parameter.");
806         return;
807     }
808 
809     dataParcelNoBearerType.WriteString(ident);
810 
811     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_IFACENAME_BY_TYPE), dataParcelNoBearerType);
812 
813     MessageParcel dataParcelNoIdent;
814     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoIdent)) {
815         NETMGR_LOG_D("GetIfaceNameByTypeFuzzTest write token failed or invalid parameter.");
816         return;
817     }
818 
819     dataParcel.WriteUint32(bearerType);
820     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_IFACENAME_BY_TYPE), dataParcelNoIdent);
821 }
822 
RegisterNetDetectionCallbackFuzzTest(const uint8_t * data,size_t size)823 void RegisterNetDetectionCallbackFuzzTest(const uint8_t *data, size_t size)
824 {
825     int32_t netId = NetConnGetData<int32_t>();
826     sptr<INetDetectionCallbackTest> callback = new (std::nothrow) INetDetectionCallbackTest();
827     if (callback == nullptr) {
828         return;
829     }
830 
831     MessageParcel dataParcel;
832     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
833         return;
834     }
835 
836     dataParcel.WriteInt32(netId);
837     dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
838 
839     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_DETECTION_RET_CALLBACK),
840                     dataParcel);
841 
842     MessageParcel dataParcelNoNetId;
843     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetId)) {
844         return;
845     }
846 
847     dataParcelNoNetId.WriteRemoteObject(callback->AsObject().GetRefPtr());
848 
849     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_DETECTION_RET_CALLBACK),
850                     dataParcelNoNetId);
851 
852     MessageParcel dataParcelNoRemoteObject;
853     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoRemoteObject)) {
854         return;
855     }
856     dataParcelNoRemoteObject.WriteInt32(netId);
857     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_DETECTION_RET_CALLBACK),
858                     dataParcelNoRemoteObject);
859 }
860 
UnRegisterNetDetectionCallbackFuzzTest(const uint8_t * data,size_t size)861 void UnRegisterNetDetectionCallbackFuzzTest(const uint8_t *data, size_t size)
862 {
863     int32_t netId = NetConnGetData<int32_t>();
864     sptr<INetDetectionCallbackTest> callback = new (std::nothrow) INetDetectionCallbackTest();
865     if (callback == nullptr) {
866         return;
867     }
868 
869     MessageParcel dataParcel;
870     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
871         return;
872     }
873 
874     dataParcel.WriteInt32(netId);
875     dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
876 
877     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UNREGISTER_NET_DETECTION_RET_CALLBACK),
878                     dataParcel);
879 
880     MessageParcel dataParcelNoNetId;
881     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetId)) {
882         return;
883     }
884 
885     dataParcelNoNetId.WriteRemoteObject(callback->AsObject().GetRefPtr());
886 
887     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UNREGISTER_NET_DETECTION_RET_CALLBACK),
888                     dataParcelNoNetId);
889 
890     MessageParcel dataParcelNoRemoteObject;
891     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
892         return;
893     }
894 
895     dataParcelNoRemoteObject.WriteInt32(netId);
896 
897     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UNREGISTER_NET_DETECTION_RET_CALLBACK),
898                     dataParcelNoRemoteObject);
899 }
900 
GetSpecificNetFuzzTest(const uint8_t * data,size_t size)901 void GetSpecificNetFuzzTest(const uint8_t *data, size_t size)
902 {
903     uint32_t bearerType = NetConnGetData<uint32_t>() % CREATE_NET_TYPE_VALUE;
904 
905     MessageParcel dataParcel;
906     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
907         return;
908     }
909 
910     dataParcel.WriteUint32(bearerType);
911 
912     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_SPECIFIC_NET), dataParcel);
913 
914     MessageParcel dataParcelNoBearerType;
915     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoBearerType)) {
916         return;
917     }
918 
919     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_SPECIFIC_NET), dataParcelNoBearerType);
920 }
921 
OnSetAppNetFuzzTest(const uint8_t * data,size_t size)922 void OnSetAppNetFuzzTest(const uint8_t *data, size_t size)
923 {
924     int32_t netId = NetConnGetData<int32_t>();
925 
926     MessageParcel dataParcel;
927     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
928         return;
929     }
930 
931     dataParcel.WriteInt32(netId);
932 
933     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_APP_NET), dataParcel);
934 
935     MessageParcel dataParcelNoNetId;
936     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetId)) {
937         return;
938     }
939 
940     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_APP_NET), dataParcelNoNetId);
941 }
942 
GetSpecificUidNetFuzzTest(const uint8_t * data,size_t size)943 void GetSpecificUidNetFuzzTest(const uint8_t *data, size_t size)
944 {
945     int32_t uid = NetConnGetData<int32_t>();
946     int32_t netId = NetConnGetData<int32_t>();
947 
948     MessageParcel dataParcel;
949     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
950         return;
951     }
952 
953     dataParcel.WriteInt32(uid);
954     dataParcel.WriteInt32(netId);
955 
956     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_SPECIFIC_UID_NET), dataParcel);
957 
958     MessageParcel dataParcelNoUid;
959     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoUid)) {
960         return;
961     }
962 
963     dataParcelNoUid.WriteInt32(netId);
964 
965     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_SPECIFIC_UID_NET), dataParcelNoUid);
966 
967     MessageParcel dataParcelNoNetId;
968     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetId)) {
969         return;
970     }
971     dataParcel.WriteInt32(uid);
972     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_SPECIFIC_UID_NET), dataParcelNoNetId);
973 }
974 
AddNetworkRouteFuzzTest(const uint8_t * data,size_t size)975 void AddNetworkRouteFuzzTest(const uint8_t *data, size_t size)
976 {
977     int32_t netId = NetConnGetData<int32_t>();
978     std::string ifName = NetConnGetString(STR_LEN);
979     std::string destination = NetConnGetString(STR_LEN);
980     std::string nextHop = NetConnGetString(STR_LEN);
981     MessageParcel dataParcel;
982     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
983         NETMGR_LOG_D("AddNetworkRouteFuzzTest write token failed or invalid parameter.");
984         return;
985     }
986     dataParcel.WriteInt32(netId);
987     dataParcel.WriteString(ifName);
988     dataParcel.WriteString(destination);
989     dataParcel.WriteString(nextHop);
990     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_NET_ROUTE), dataParcel);
991     MessageParcel dataParcelNoNetId;
992     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetId)) {
993         NETMGR_LOG_D("AddNetworkRouteFuzzTest write token failed or invalid parameter.");
994         return;
995     }
996     dataParcelNoNetId.WriteString(ifName);
997     dataParcelNoNetId.WriteString(destination);
998     dataParcelNoNetId.WriteString(nextHop);
999     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_NET_ROUTE), dataParcelNoNetId);
1000     MessageParcel dataParcelNoIfName;
1001     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoIfName)) {
1002         NETMGR_LOG_D("AddNetworkRouteFuzzTest write token failed or invalid parameter.");
1003         return;
1004     }
1005     dataParcelNoIfName.WriteInt32(netId);
1006     dataParcelNoIfName.WriteString(destination);
1007     dataParcelNoIfName.WriteString(nextHop);
1008     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_NET_ROUTE), dataParcelNoIfName);
1009     MessageParcel dataParcelNoDest;
1010     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoDest)) {
1011         NETMGR_LOG_D("AddNetworkRouteFuzzTest write token failed or invalid parameter.");
1012         return;
1013     }
1014     dataParcelNoDest.WriteInt32(netId);
1015     dataParcelNoDest.WriteString(ifName);
1016     dataParcelNoDest.WriteString(nextHop);
1017     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_NET_ROUTE), dataParcelNoDest);
1018 }
1019 
RemoveNetworkRouteFuzzTest(const uint8_t * data,size_t size)1020 void RemoveNetworkRouteFuzzTest(const uint8_t *data, size_t size)
1021 {
1022     int32_t netId = NetConnGetData<int32_t>();
1023     std::string ifName = NetConnGetString(STR_LEN);
1024     std::string destination = NetConnGetString(STR_LEN);
1025     std::string nextHop = NetConnGetString(STR_LEN);
1026     MessageParcel dataParcel;
1027     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1028         NETMGR_LOG_D("RemoveNetworkRouteFuzzTest write token failed or invalid parameter.");
1029         return;
1030     }
1031     dataParcel.WriteInt32(netId);
1032     dataParcel.WriteString(ifName);
1033     dataParcel.WriteString(destination);
1034     dataParcel.WriteString(nextHop);
1035     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REMOVE_NET_ROUTE), dataParcel);
1036     MessageParcel dataParcelNoNetId;
1037     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetId)) {
1038         NETMGR_LOG_D("RemoveNetworkRouteFuzzTest write token failed or invalid parameter.");
1039         return;
1040     }
1041     dataParcelNoNetId.WriteString(ifName);
1042     dataParcelNoNetId.WriteString(destination);
1043     dataParcelNoNetId.WriteString(nextHop);
1044     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REMOVE_NET_ROUTE), dataParcelNoNetId);
1045     MessageParcel dataParcelNoIfName;
1046     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoIfName)) {
1047         NETMGR_LOG_D("RemoveNetworkRouteFuzzTest write token failed or invalid parameter.");
1048         return;
1049     }
1050     dataParcelNoIfName.WriteInt32(netId);
1051     dataParcelNoIfName.WriteString(destination);
1052     dataParcelNoIfName.WriteString(nextHop);
1053     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REMOVE_NET_ROUTE), dataParcelNoIfName);
1054     MessageParcel dataParcelNoDest;
1055     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoDest)) {
1056         NETMGR_LOG_D("RemoveNetworkRouteFuzzTest write token failed or invalid parameter.");
1057         return;
1058     }
1059     dataParcelNoDest.WriteInt32(netId);
1060     dataParcelNoDest.WriteString(ifName);
1061     dataParcelNoDest.WriteString(nextHop);
1062     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REMOVE_NET_ROUTE), dataParcelNoDest);
1063 }
1064 
AddInterfaceAddressFuzzTest(const uint8_t * data,size_t size)1065 void AddInterfaceAddressFuzzTest(const uint8_t *data, size_t size)
1066 {
1067     int32_t prefixLength = NetConnGetData<int32_t>();
1068     std::string ifName = NetConnGetString(STR_LEN);
1069     std::string ipAddr = NetConnGetString(STR_LEN);
1070 
1071     MessageParcel dataParcel;
1072     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1073         NETMGR_LOG_D("AddInterfaceAddressFuzzTest write token failed or invalid parameter.");
1074         return;
1075     }
1076     dataParcel.WriteString(ifName);
1077     dataParcel.WriteString(ipAddr);
1078     dataParcel.WriteInt32(prefixLength);
1079 
1080     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_NET_ADDRESS), dataParcel);
1081 
1082     MessageParcel dataParcelNoIfName;
1083     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoIfName)) {
1084         NETMGR_LOG_D("AddInterfaceAddressFuzzTest write token failed or invalid parameter.");
1085         return;
1086     }
1087     dataParcelNoIfName.WriteString(ipAddr);
1088     dataParcelNoIfName.WriteInt32(prefixLength);
1089 
1090     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_NET_ADDRESS), dataParcelNoIfName);
1091 
1092     MessageParcel dataParcelNoIpAddr;
1093     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoIpAddr)) {
1094         NETMGR_LOG_D("AddInterfaceAddressFuzzTest write token failed or invalid parameter.");
1095         return;
1096     }
1097     dataParcelNoIpAddr.WriteString(ifName);
1098     dataParcelNoIpAddr.WriteInt32(prefixLength);
1099 
1100     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_NET_ADDRESS), dataParcelNoIpAddr);
1101 
1102     MessageParcel dataParcelNoPrefix;
1103     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoPrefix)) {
1104         NETMGR_LOG_D("AddInterfaceAddressFuzzTest write token failed or invalid parameter.");
1105         return;
1106     }
1107     dataParcelNoPrefix.WriteString(ifName);
1108     dataParcelNoPrefix.WriteString(ipAddr);
1109 
1110     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_NET_ADDRESS), dataParcelNoPrefix);
1111 }
1112 
DelInterfaceAddressFuzzTest(const uint8_t * data,size_t size)1113 void DelInterfaceAddressFuzzTest(const uint8_t *data, size_t size)
1114 {
1115     int32_t prefixLength = NetConnGetData<int32_t>();
1116     std::string ifName = NetConnGetString(STR_LEN);
1117     std::string ipAddr = NetConnGetString(STR_LEN);
1118 
1119     MessageParcel dataParcel;
1120     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1121         NETMGR_LOG_D("DelInterfaceAddressFuzzTest write token failed or invalid parameter.");
1122         return;
1123     }
1124     dataParcel.WriteString(ifName);
1125     dataParcel.WriteString(ipAddr);
1126     dataParcel.WriteInt32(prefixLength);
1127 
1128     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REMOVE_NET_ADDRESS), dataParcel);
1129 
1130     MessageParcel dataParcelNoIfName;
1131     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoIfName)) {
1132         NETMGR_LOG_D("DelInterfaceAddressFuzzTest write token failed or invalid parameter.");
1133         return;
1134     }
1135     dataParcelNoIfName.WriteString(ipAddr);
1136     dataParcelNoIfName.WriteInt32(prefixLength);
1137 
1138     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REMOVE_NET_ADDRESS), dataParcelNoIfName);
1139 
1140     MessageParcel dataParcelNoIpAddr;
1141     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoIpAddr)) {
1142         NETMGR_LOG_D("DelInterfaceAddressFuzzTest write token failed or invalid parameter.");
1143         return;
1144     }
1145     dataParcelNoIpAddr.WriteString(ifName);
1146     dataParcelNoIpAddr.WriteInt32(prefixLength);
1147 
1148     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REMOVE_NET_ADDRESS), dataParcelNoIpAddr);
1149 
1150     MessageParcel dataParcelNoPrefix;
1151     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoPrefix)) {
1152         NETMGR_LOG_D("DelInterfaceAddressFuzzTest write token failed or invalid parameter.");
1153         return;
1154     }
1155     dataParcelNoPrefix.WriteString(ifName);
1156     dataParcelNoPrefix.WriteString(ipAddr);
1157 
1158     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REMOVE_NET_ADDRESS), dataParcelNoPrefix);
1159 }
1160 
StaticArpProcess(const uint8_t * data,size_t size,MessageParcel & dataParcel)1161 void StaticArpProcess(const uint8_t *data, size_t size, MessageParcel &dataParcel)
1162 {
1163     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1164         return;
1165     }
1166 
1167     std::string ipAddr = NetConnGetString(STR_LEN);
1168     std::string macAddr = NetConnGetString(STR_LEN);
1169     std::string ifName = NetConnGetString(STR_LEN);
1170     dataParcel.WriteString(ipAddr);
1171     dataParcel.WriteString(macAddr);
1172     dataParcel.WriteString(ifName);
1173 }
1174 
StaticArpProcessNoIpAddr(const uint8_t * data,size_t size,MessageParcel & dataParcel)1175 void StaticArpProcessNoIpAddr(const uint8_t *data, size_t size, MessageParcel &dataParcel)
1176 {
1177     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1178         return;
1179     }
1180 
1181     std::string macAddr = NetConnGetString(STR_LEN);
1182     std::string ifName = NetConnGetString(STR_LEN);
1183     dataParcel.WriteString(macAddr);
1184     dataParcel.WriteString(ifName);
1185 }
1186 
StaticArpProcessNoMacAddr(const uint8_t * data,size_t size,MessageParcel & dataParcel)1187 void StaticArpProcessNoMacAddr(const uint8_t *data, size_t size, MessageParcel &dataParcel)
1188 {
1189     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1190         return;
1191     }
1192 
1193     std::string ipAddr = NetConnGetString(STR_LEN);
1194     std::string ifName = NetConnGetString(STR_LEN);
1195     dataParcel.WriteString(ipAddr);
1196     dataParcel.WriteString(ifName);
1197 }
1198 
StaticArpProcessNoIfName(const uint8_t * data,size_t size,MessageParcel & dataParcel)1199 void StaticArpProcessNoIfName(const uint8_t *data, size_t size, MessageParcel &dataParcel)
1200 {
1201     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1202         return;
1203     }
1204 
1205     std::string ipAddr = NetConnGetString(STR_LEN);
1206     std::string macAddr = NetConnGetString(STR_LEN);
1207     dataParcel.WriteString(ipAddr);
1208     dataParcel.WriteString(macAddr);
1209 }
1210 
AddStaticArpFuzzTest(const uint8_t * data,size_t size)1211 void AddStaticArpFuzzTest(const uint8_t *data, size_t size)
1212 {
1213     MessageParcel dataParcel;
1214     StaticArpProcess(data, size, dataParcel);
1215     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_STATIC_ARP), dataParcel);
1216 
1217     MessageParcel dataParcelNoIpAddr;
1218     StaticArpProcessNoIpAddr(data, size, dataParcelNoIpAddr);
1219     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_STATIC_ARP), dataParcelNoIpAddr);
1220 
1221     MessageParcel dataParcelNoMacAddr;
1222     StaticArpProcessNoMacAddr(data, size, dataParcelNoMacAddr);
1223     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_STATIC_ARP), dataParcelNoMacAddr);
1224 
1225     MessageParcel dataParcelNoIfName;
1226     StaticArpProcessNoIfName(data, size, dataParcelNoIfName);
1227     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_STATIC_ARP), dataParcelNoIfName);
1228 }
1229 
DelStaticArpFuzzTest(const uint8_t * data,size_t size)1230 void DelStaticArpFuzzTest(const uint8_t *data, size_t size)
1231 {
1232     MessageParcel dataParcel;
1233     StaticArpProcess(data, size, dataParcel);
1234     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_DEL_STATIC_ARP), dataParcel);
1235 
1236     MessageParcel dataParcelNoIpAddr;
1237     StaticArpProcessNoIpAddr(data, size, dataParcel);
1238     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_DEL_STATIC_ARP), dataParcelNoIpAddr);
1239 
1240     MessageParcel dataParcelNoMacAddr;
1241     StaticArpProcessNoMacAddr(data, size, dataParcel);
1242     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_DEL_STATIC_ARP), dataParcelNoMacAddr);
1243 
1244     MessageParcel dataParcelNoIfName;
1245     StaticArpProcessNoIfName(data, size, dataParcel);
1246     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_DEL_STATIC_ARP), dataParcelNoIfName);
1247 }
1248 
RegisterSlotTypeFuzzTest(const uint8_t * data,size_t size)1249 void RegisterSlotTypeFuzzTest(const uint8_t *data, size_t size)
1250 {
1251     int32_t supplierId = NetConnGetData<int32_t>();
1252     int32_t type = NetConnGetData<int32_t>();
1253 
1254     MessageParcel dataParcel;
1255     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1256         NETMGR_LOG_D("DelInterfaceAddressFuzzTest write token failed or invalid parameter.");
1257         return;
1258     }
1259     dataParcel.WriteInt32(supplierId);
1260     dataParcel.WriteInt32(type);
1261     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_SLOT_TYPE), dataParcel);
1262 
1263     MessageParcel dataParcelNoSupplierId;
1264     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoSupplierId)) {
1265         NETMGR_LOG_D("DelInterfaceAddressFuzzTest write token failed or invalid parameter.");
1266         return;
1267     }
1268     dataParcelNoSupplierId.WriteInt32(type);
1269     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_SLOT_TYPE), dataParcelNoSupplierId);
1270 
1271     MessageParcel dataParcelNoType;
1272     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoType)) {
1273         NETMGR_LOG_D("DelInterfaceAddressFuzzTest write token failed or invalid parameter.");
1274         return;
1275     }
1276     dataParcel.WriteInt32(supplierId);
1277     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_SLOT_TYPE), dataParcelNoType);
1278 }
1279 
GetSlotTypeFuzzTest(const uint8_t * data,size_t size)1280 void GetSlotTypeFuzzTest(const uint8_t *data, size_t size)
1281 {
1282     MessageParcel dataParcel;
1283     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1284         NETMGR_LOG_D("DelInterfaceAddressFuzzTest write token failed or invalid parameter.");
1285         return;
1286     }
1287     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_SLOT_TYPE), dataParcel);
1288 }
1289 
IsPreferCellularUrlFuzzTest(const uint8_t * data,size_t size)1290 void IsPreferCellularUrlFuzzTest(const uint8_t *data, size_t size)
1291 {
1292     std::string url = NetConnGetString(STR_LEN);
1293     MessageParcel dataParcel;
1294     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1295         NETMGR_LOG_D("DelInterfaceAddressFuzzTest write token failed or invalid parameter.");
1296         return;
1297     }
1298     dataParcel.WriteString(url);
1299     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_IS_PREFER_CELLULAR_URL), dataParcel);
1300 
1301     MessageParcel dataParcelNoUrl;
1302     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoUrl)) {
1303         NETMGR_LOG_D("DelInterfaceAddressFuzzTest write token failed or invalid parameter.");
1304         return;
1305     }
1306     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_IS_PREFER_CELLULAR_URL), dataParcelNoUrl);
1307 }
1308 
StaticUpdateSupplierScoreProcess(const uint8_t * data,size_t size,MessageParcel & dataParcel,uint8_t paramsModel)1309 void StaticUpdateSupplierScoreProcess(const uint8_t *data, size_t size, MessageParcel &dataParcel, uint8_t paramsModel)
1310 {
1311     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1312         return;
1313     }
1314     // ! without the first param.
1315     if (paramsModel != WITHOUT_FIRST_PARM_MODEL) {
1316         int32_t supplierId = NetConnGetData<int32_t>();
1317         dataParcel.WriteInt32(supplierId);
1318     }
1319     // ! without the second param.
1320     if (paramsModel != WITHOUT_SECOND_PARM_MODEL) {
1321         bool isBetter = NetConnGetData<bool>();
1322         dataParcel.WriteBool(isBetter);
1323     }
1324     // ! without the third param.
1325     if (paramsModel != WITHOUT_THIRD_PARM_MODEL) {
1326         int32_t type = NetConnGetData<int32_t>();
1327         dataParcel.WriteInt32(type);
1328     }
1329 }
1330 
UpdateSupplierScoreFuzzTest(const uint8_t * data,size_t size)1331 void UpdateSupplierScoreFuzzTest(const uint8_t *data, size_t size)
1332 {
1333     MessageParcel dataParcelWithAllParam;
1334     StaticUpdateSupplierScoreProcess(data, size, dataParcelWithAllParam, WITH_ALL_PARM_MODEL);
1335     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UPDATE_SUPPLIER_SCORE), dataParcelWithAllParam);
1336 
1337     MessageParcel dataParcelWithOutFirstParam;
1338     StaticUpdateSupplierScoreProcess(data, size, dataParcelWithAllParam, WITHOUT_FIRST_PARM_MODEL);
1339     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UPDATE_SUPPLIER_SCORE),
1340                     dataParcelWithOutFirstParam);
1341 
1342     MessageParcel dataParcelWithOutSecondParam;
1343     StaticUpdateSupplierScoreProcess(data, size, dataParcelWithAllParam, WITHOUT_SECOND_PARM_MODEL);
1344     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UPDATE_SUPPLIER_SCORE),
1345                     dataParcelWithOutSecondParam);
1346 
1347     MessageParcel dataParcelWithOutThirdParam;
1348     StaticUpdateSupplierScoreProcess(data, size, dataParcelWithAllParam, WITHOUT_THIRD_PARM_MODEL);
1349     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UPDATE_SUPPLIER_SCORE),
1350                     dataParcelWithOutThirdParam);
1351 }
1352 
RegisterPreAirplaneCallbackFuzzTest(const uint8_t * data,size_t size)1353 void RegisterPreAirplaneCallbackFuzzTest(const uint8_t *data, size_t size)
1354 {
1355     NetManagerBaseAccessToken token;
1356     sptr<IPreAirplaneCallbackStubTestCb> callback = new (std::nothrow) IPreAirplaneCallbackStubTestCb();
1357     if (callback == nullptr) {
1358         return;
1359     }
1360 
1361     MessageParcel dataParcel;
1362     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1363         return;
1364     }
1365     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_PREAIRPLANE_CALLBACK), dataParcel);
1366 
1367     dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
1368 
1369     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_PREAIRPLANE_CALLBACK), dataParcel);
1370 }
1371 
UnregisterPreAirplaneCallbackFuzzTest(const uint8_t * data,size_t size)1372 void UnregisterPreAirplaneCallbackFuzzTest(const uint8_t *data, size_t size)
1373 {
1374     NetManagerBaseAccessToken token;
1375     sptr<IPreAirplaneCallbackStubTestCb> callback = new (std::nothrow) IPreAirplaneCallbackStubTestCb();
1376     if (callback == nullptr) {
1377         return;
1378     }
1379 
1380     MessageParcel dataParcel;
1381     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1382         return;
1383     }
1384     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UNREGISTER_PREAIRPLANE_CALLBACK), dataParcel);
1385 
1386     dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
1387 
1388     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UNREGISTER_PREAIRPLANE_CALLBACK), dataParcel);
1389 }
1390 } // namespace NetManagerStandard
1391 } // namespace OHOS
1392 
1393 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)1394 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
1395 {
1396     /* Run your code on data */
1397     OHOS::NetManagerStandard::SystemReadyFuzzTest(data, size);
1398     OHOS::NetManagerStandard::RegisterNetSupplierFuzzTest(data, size);
1399     OHOS::NetManagerStandard::UnregisterNetSupplierFuzzTest(data, size);
1400     OHOS::NetManagerStandard::RegisterNetSupplierCallbackFuzzTest(data, size);
1401     OHOS::NetManagerStandard::UpdateNetSupplierInfoFuzzTest(data, size);
1402     OHOS::NetManagerStandard::UpdateNetLinkInfoFuzzTest(data, size);
1403     OHOS::NetManagerStandard::RegisterNetConnCallbackBySpecifierFuzzTest(data, size);
1404     OHOS::NetManagerStandard::RegisterNetConnCallbackFuzzTest(data, size);
1405     OHOS::NetManagerStandard::UnregisterNetConnCallbackFuzzTest(data, size);
1406     OHOS::NetManagerStandard::GetDefaultNetFuzzTest(data, size);
1407     OHOS::NetManagerStandard::HasDefaultNetFuzzTest(data, size);
1408     OHOS::NetManagerStandard::GetAllNetsFuzzTest(data, size);
1409     OHOS::NetManagerStandard::GetConnectionPropertiesFuzzTest(data, size);
1410     OHOS::NetManagerStandard::GetNetCapabilitiesFuzzTest(data, size);
1411     OHOS::NetManagerStandard::GetAddressesByNameFuzzTest(data, size);
1412     OHOS::NetManagerStandard::GetAddressByNameFuzzTest(data, size);
1413     OHOS::NetManagerStandard::BindSocketFuzzTest(data, size);
1414     OHOS::NetManagerStandard::NetDetectionFuzzTest(data, size);
1415     OHOS::NetManagerStandard::SetAirplaneModeFuzzTest(data, size);
1416     OHOS::NetManagerStandard::IsDefaultNetMeteredFuzzTest(data, size);
1417     OHOS::NetManagerStandard::SetGlobalHttpProxyFuzzTest(data, size);
1418     OHOS::NetManagerStandard::GetGlobalHttpProxyFuzzTest(data, size);
1419     OHOS::NetManagerStandard::GetDefaultHttpProxyFuzzTest(data, size);
1420     OHOS::NetManagerStandard::SetAppHttpProxyFuzzTest(data, size);
1421     OHOS::NetManagerStandard::RegisterAppHttpProxyCallbackFuzzTest(data, size);
1422     OHOS::NetManagerStandard::UnregisterAppHttpProxyCallbackFuzzTest(data, size);
1423     OHOS::NetManagerStandard::GetNetIdByIdentifierFuzzTest(data, size);
1424     OHOS::NetManagerStandard::RegisterNetInterfaceCallbackFuzzTest(data, size);
1425     OHOS::NetManagerStandard::GetNetInterfaceConfigurationFuzzTest(data, size);
1426     OHOS::NetManagerStandard::SetInternetPermissionFuzzTest(data, size);
1427     OHOS::NetManagerStandard::UpdateNetStateForTestFuzzTest(data, size);
1428     OHOS::NetManagerStandard::GetIfaceNamesFuzzTest(data, size);
1429     OHOS::NetManagerStandard::GetIfaceNameByTypeFuzzTest(data, size);
1430     OHOS::NetManagerStandard::RegisterNetDetectionCallbackFuzzTest(data, size);
1431     OHOS::NetManagerStandard::UnRegisterNetDetectionCallbackFuzzTest(data, size);
1432     OHOS::NetManagerStandard::GetSpecificNetFuzzTest(data, size);
1433     OHOS::NetManagerStandard::GetSpecificUidNetFuzzTest(data, size);
1434     OHOS::NetManagerStandard::OnSetAppNetFuzzTest(data, size);
1435     OHOS::NetManagerStandard::AddNetworkRouteFuzzTest(data, size);
1436     OHOS::NetManagerStandard::RemoveNetworkRouteFuzzTest(data, size);
1437     OHOS::NetManagerStandard::AddInterfaceAddressFuzzTest(data, size);
1438     OHOS::NetManagerStandard::DelInterfaceAddressFuzzTest(data, size);
1439     OHOS::NetManagerStandard::AddStaticArpFuzzTest(data, size);
1440     OHOS::NetManagerStandard::DelStaticArpFuzzTest(data, size);
1441     return 0;
1442 }
1443