1/*
2 * Copyright (C) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16#include <cstddef>
17#include <cstdint>
18#include <unistd.h>
19#include "dhcpserverimpl_fuzzer.h"
20#include "securec.h"
21#include "dhcp_server_service_impl.h"
22#include "dhcp_server_death_recipient.h"
23#include "iremote_object.h"
24
25namespace OHOS {
26namespace DHCP {
27constexpr size_t U32_AT_SIZE_ZERO = 4;
28constexpr size_t DHCP_SLEEP_1 = 2;
29sptr<DhcpServerServiceImpl> pDhcpServerServiceImpl = DhcpServerServiceImpl::GetInstance();
30
31void OnStartTest(const uint8_t* data, size_t size)
32{
33    pDhcpServerServiceImpl->OnStart();
34}
35
36void OnStopTest(const uint8_t* data, size_t size)
37{
38    pDhcpServerServiceImpl->OnStop();
39}
40
41void StartDhcpServerTest(const uint8_t* data, size_t size)
42{
43    std::string ifname = "";
44    pDhcpServerServiceImpl->StartDhcpServer(ifname);
45}
46
47void StopDhcpServerTest(const uint8_t* data, size_t size)
48{
49    std::string ifname1 = "wlan0";
50    std::string ifname2 = "";
51    pDhcpServerServiceImpl->StopDhcpServer(ifname1);
52    pDhcpServerServiceImpl->StopDhcpServer(ifname2);
53}
54
55void PutDhcpRangeTest(const uint8_t* data, size_t size)
56{
57    std::string tagName = "sta";
58    DhcpRange range;
59    range.iptype = 0;
60    pDhcpServerServiceImpl->PutDhcpRange(tagName, range);
61    pDhcpServerServiceImpl->PutDhcpRange("", range);
62}
63
64void RemoveDhcpRangeTest(const uint8_t* data, size_t size)
65{
66    std::string tagName = "sta";
67    DhcpRange range;
68    range.iptype = 0;
69    pDhcpServerServiceImpl->RemoveDhcpRange(tagName, range);
70    pDhcpServerServiceImpl->RemoveDhcpRange("", range);
71}
72
73void RemoveAllDhcpRangeTest(const uint8_t* data, size_t size)
74{
75    std::string tagName1 = "sta";
76    std::string tagName2 = "";
77    pDhcpServerServiceImpl->RemoveAllDhcpRange(tagName1);
78    pDhcpServerServiceImpl->RemoveAllDhcpRange(tagName2);
79}
80
81void SetDhcpRangeTest(const uint8_t* data, size_t size)
82{
83    std::string ifname = "wlan0";
84    DhcpRange range;
85    range.iptype = 0;
86    pDhcpServerServiceImpl->SetDhcpRange(ifname, range);
87}
88
89void SetDhcpNameTest(const uint8_t* data, size_t size)
90{
91    std::string ifname = "wlan0";
92    std::string tagName = "sta";
93    pDhcpServerServiceImpl->SetDhcpName(ifname, tagName);
94    pDhcpServerServiceImpl->SetDhcpName("", tagName);
95    pDhcpServerServiceImpl->SetDhcpName(ifname, "");
96    pDhcpServerServiceImpl->SetDhcpName("", "");
97}
98
99void GetDhcpClientInfosTest(const uint8_t* data, size_t size)
100{
101    std::string ifname1 = "";
102    std::string ifname2 = "wlan0";
103    std::vector<std::string> leases;
104    leases.push_back(std::string(reinterpret_cast<const char*>(data), size));
105    pDhcpServerServiceImpl->GetDhcpClientInfos(ifname1, leases);
106    pDhcpServerServiceImpl->GetDhcpClientInfos(ifname2, leases);
107}
108
109void UpdateLeasesTimeTest(const uint8_t* data, size_t size)
110{
111    std::string leaseTime = std::string(reinterpret_cast<const char*>(data), size);
112    pDhcpServerServiceImpl->UpdateLeasesTime(leaseTime);
113}
114
115void IsRemoteDiedTest(const uint8_t* data, size_t size)
116{
117    pDhcpServerServiceImpl->IsRemoteDied();
118}
119
120void DeleteLeaseFileTest(const uint8_t* data, size_t size)
121{
122    std::string ifname = "wlan0";
123    pDhcpServerServiceImpl->DeleteLeaseFile(ifname);
124}
125
126void CheckAndUpdateConfTest(const uint8_t* data, size_t size)
127{
128    std::string ifname1 = "";
129    std::string ifname2 = "wlan0";
130    pDhcpServerServiceImpl->CheckAndUpdateConf(ifname1);
131    pDhcpServerServiceImpl->CheckAndUpdateConf(ifname2);
132}
133
134void CheckIpAddrRangeTest(const uint8_t* data, size_t size)
135{
136    DhcpRange range;
137    int call = 2;
138    range.strTagName = std::string(reinterpret_cast<const char*>(data), size);
139    range.strStartip = std::string(reinterpret_cast<const char*>(data), size);
140    range.strEndip = std::string(reinterpret_cast<const char*>(data), size);
141    range.strSubnet = std::string(reinterpret_cast<const   char*>(data), size);
142    range.iptype = static_cast<int>(data[0]) % call;
143    range.leaseHours = static_cast<int>(data[0]);
144    pDhcpServerServiceImpl->CheckIpAddrRange(range);
145}
146
147void AddSpecifiedInterfaceTest(const uint8_t* data, size_t size)
148{
149    std::string ifname = "wlan0";
150    pDhcpServerServiceImpl->AddSpecifiedInterface(ifname);
151}
152
153void GetUsingIpRangeTest(const uint8_t* data, size_t size)
154{
155    std::string ifname1 = "";
156    std::string ifname2 = "ww";
157    std::string ifname3 = "wlan0";
158    std::string ipRange = std::string(reinterpret_cast<const char*>(data), size);
159    pDhcpServerServiceImpl->GetUsingIpRange(ifname1, ipRange);
160    pDhcpServerServiceImpl->GetUsingIpRange(ifname2, ipRange);
161    pDhcpServerServiceImpl->GetUsingIpRange(ifname3, ipRange);
162}
163
164void CreateDefaultConfigFileTest(const uint8_t* data, size_t size)
165{
166    std::string strFile = std::string(reinterpret_cast<const char*>(data), size);
167    pDhcpServerServiceImpl->CreateDefaultConfigFile(strFile);
168}
169
170void UnregisterSignalTest(const uint8_t* data, size_t size)
171{
172    pDhcpServerServiceImpl->UnregisterSignal();
173}
174
175void DelSpecifiedInterfaceTest(const uint8_t* data, size_t size)
176{
177    std::string ifname = std::string(reinterpret_cast<const char*>(data), size);
178    pDhcpServerServiceImpl->DelSpecifiedInterface(ifname);
179}
180
181void RegisterDhcpServerCallBackTest(const uint8_t* data, size_t size)
182{
183    std::string ifname = std::string(reinterpret_cast<const char*>(data), size);
184    sptr<IDhcpServerCallBack> serverCallback;
185    pDhcpServerServiceImpl->RegisterDhcpServerCallBack(ifname, serverCallback);
186}
187
188void StartServiceAbilityTest(const uint8_t* data, size_t size)
189{
190    int index = 0;
191    int sleepS = static_cast<int>(index++);
192    pDhcpServerServiceImpl->StartServiceAbility(sleepS);
193}
194
195/* Fuzzer entry point */
196extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
197{
198    if ((data == nullptr) || (size <= OHOS::DHCP::U32_AT_SIZE_ZERO)) {
199        return 0;
200    }
201    sleep(DHCP_SLEEP_1);
202    OHOS::DHCP::OnStartTest(data, size);
203    OHOS::DHCP::OnStopTest(data, size);
204    OHOS::DHCP::StartDhcpServerTest(data, size);
205    OHOS::DHCP::StopDhcpServerTest(data, size);
206    OHOS::DHCP::PutDhcpRangeTest(data, size);
207    OHOS::DHCP::RemoveDhcpRangeTest(data, size);
208    OHOS::DHCP::RemoveAllDhcpRangeTest(data, size);
209    OHOS::DHCP::SetDhcpRangeTest(data, size);
210    OHOS::DHCP::SetDhcpNameTest(data, size);
211    OHOS::DHCP::GetDhcpClientInfosTest(data, size);
212    OHOS::DHCP::UpdateLeasesTimeTest(data, size);
213    OHOS::DHCP::IsRemoteDiedTest(data, size);
214    OHOS::DHCP::DeleteLeaseFileTest(data, size);
215    OHOS::DHCP::CheckAndUpdateConfTest(data, size);
216    OHOS::DHCP::CheckIpAddrRangeTest(data, size);
217    OHOS::DHCP::AddSpecifiedInterfaceTest(data, size);
218    OHOS::DHCP::GetUsingIpRangeTest(data, size);
219    OHOS::DHCP::CreateDefaultConfigFileTest(data, size);
220    OHOS::DHCP::UnregisterSignalTest(data, size);
221    OHOS::DHCP::DelSpecifiedInterfaceTest(data, size);
222    OHOS::DHCP::RegisterDhcpServerCallBackTest(data, size);
223    OHOS::DHCP::StartServiceAbilityTest(data, size);
224    return 0;
225}
226}  // namespace DHCP
227}  // namespace OHOS
228