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 "dhcpfunction_fuzzer.h"
17
18#include <cstddef>
19#include <cstdint>
20#include <unistd.h>
21#include "securec.h"
22#include "dhcp_function.h"
23
24namespace OHOS {
25namespace DHCP {
26constexpr size_t DHCP_SLEEP_1 = 2;
27constexpr int TWO = 2;
28
29std::shared_ptr<DhcpFunction> pDhcpFunction = std::make_shared<DhcpFunction>();
30
31void Ip4StrConToIntTest(const uint8_t* data, size_t size)
32{
33    uint32_t index = 0;
34    uint32_t uIp = static_cast<uint32_t>(data[index++]);
35    std::string strIp = std::string(reinterpret_cast<const char*>(data), size);
36    bool bHost = (static_cast<int>(data[0]) % TWO) ? true : false;
37    pDhcpFunction->Ip4StrConToInt(strIp, uIp, bHost);
38}
39
40void Ip4IntConvertToStrTest(const uint8_t* data, size_t size)
41{
42    uint32_t index = 0;
43    uint32_t uIp = static_cast<uint32_t>(data[index++]);
44    bool bHost = (static_cast<int>(data[0]) % TWO) ? true : false;
45    pDhcpFunction->Ip4IntConvertToStr(uIp, bHost);
46}
47
48void Ip6StrConToCharTest(const uint8_t* data, size_t size)
49{
50    std::string strIp = std::string(reinterpret_cast<const char*>(data), size);
51    uint8_t	chIp[sizeof(struct in6_addr)] = {0};
52    pDhcpFunction->Ip6StrConToChar(strIp, chIp, sizeof(struct in6_addr));
53}
54
55void CheckIpStrTest(const uint8_t* data, size_t size)
56{
57    std::string strIp = std::string(reinterpret_cast<const char*>(data), size);
58    pDhcpFunction->CheckIpStr(strIp);
59}
60
61void IsExistFileTest(const uint8_t* data, size_t size)
62{
63    std::string filename = std::string(reinterpret_cast<const char*>(data), size);
64    pDhcpFunction->IsExistFile(filename);
65}
66
67void CreateFileTest(const uint8_t* data, size_t size)
68{
69    std::string filename = std::string(reinterpret_cast<const char*>(data), size);
70    std::string filedata = std::string(reinterpret_cast<const char*>(data), size);
71    pDhcpFunction->CreateFile(filename, filedata);
72}
73
74void RemoveFileTest(const uint8_t* data, size_t size)
75{
76    std::string filename = std::string(reinterpret_cast<const char*>(data), size);
77    pDhcpFunction->RemoveFile(filename);
78}
79
80void AddFileLineDataTest(const uint8_t* data, size_t size)
81{
82    std::string filename = std::string(reinterpret_cast<const char*>(data), size);
83    std::string prevdata = std::string(reinterpret_cast<const char*>(data), size);
84    std::string linedata = std::string(reinterpret_cast<const char*>(data), size);
85    pDhcpFunction->AddFileLineData(filename, prevdata, linedata);
86}
87
88void DelFileLineDataTest(const uint8_t* data, size_t size)
89{
90    std::string filename = std::string(reinterpret_cast<const char*>(data), size);
91    std::string linedata = std::string(reinterpret_cast<const char*>(data), size);
92    pDhcpFunction->DelFileLineData(filename, linedata);
93}
94
95void ModifyFileLineDataTest(const uint8_t* data, size_t size)
96{
97    std::string filename = std::string(reinterpret_cast<const char*>(data), size);
98    std::string srcdata = std::string(reinterpret_cast<const char*>(data), size);
99    std::string dstdata = std::string(reinterpret_cast<const char*>(data), size);
100    pDhcpFunction->ModifyFileLineData(filename, srcdata, dstdata);
101}
102
103void FormatStringTest(const uint8_t* data, size_t size)
104{
105    struct DhcpPacketResult result;
106    memset_s(&result, sizeof(result), 0, sizeof(result));
107    strncpy_s(result.strYiaddr, INET_ADDRSTRLEN, "*", INET_ADDRSTRLEN - 1);
108    strncpy_s(result.strOptServerId, INET_ADDRSTRLEN, "*", INET_ADDRSTRLEN - 1);
109    strncpy_s(result.strOptSubnet, INET_ADDRSTRLEN, "*", INET_ADDRSTRLEN - 1);
110    strncpy_s(result.strOptDns1, INET_ADDRSTRLEN, "*", INET_ADDRSTRLEN - 1);
111    strncpy_s(result.strOptDns2, INET_ADDRSTRLEN, "*", INET_ADDRSTRLEN - 1);
112    strncpy_s(result.strOptRouter1, INET_ADDRSTRLEN, "*", INET_ADDRSTRLEN - 1);
113    strncpy_s(result.strOptRouter2, INET_ADDRSTRLEN, "*", INET_ADDRSTRLEN - 1);
114    strncpy_s(result.strOptVendor, DHCP_FILE_MAX_BYTES, "*", DHCP_FILE_MAX_BYTES - 1);
115    pDhcpFunction->FormatString(result);
116}
117
118void InitPidfileTest(const uint8_t* data, size_t size)
119{
120    std::string piddir = std::string(reinterpret_cast<const char*>(data), size);
121    std::string pidfile = std::string(reinterpret_cast<const char*>(data), size);
122    pDhcpFunction->InitPidfile(piddir, pidfile);
123}
124
125void GetPIDTest(const uint8_t* data, size_t size)
126{
127    std::string pidfile = std::string(reinterpret_cast<const char*>(data), size);
128    pDhcpFunction->GetPID(pidfile);
129}
130
131void CheckProRunningTest(const uint8_t* data, size_t size)
132{
133    pid_t index = 0;
134    pid_t proPid = static_cast<pid_t>(data[index++]);
135    std::string proName = std::string(reinterpret_cast<const char*>(data), size);
136    pDhcpFunction->CheckProRunning(proPid, proName);
137}
138
139void CreateDirsTest(const uint8_t* data, size_t size)
140{
141    int mode = DIR_DEFAULT_MODE;
142    std::string dirs = std::string(reinterpret_cast<const char*>(data), size);
143    pDhcpFunction->CreateDirs(dirs, mode);
144}
145
146void SplitStringTest(const uint8_t* data, size_t size)
147{
148    int index = 0;
149    int count = static_cast<int>(data[index++]);
150    std::vector<std::string> splits {};
151    std::string src = std::string(reinterpret_cast<const char*>(data), size);
152    std::string delim = std::string(reinterpret_cast<const char*>(data), size);
153    pDhcpFunction->SplitString(src, delim, count, splits);
154}
155
156void WaitProcessExitTest(const uint8_t* data, size_t size)
157{
158    pid_t index = 0;
159    pid_t serverPid = static_cast<pid_t>(data[index++]);
160    pDhcpFunction->WaitProcessExit(serverPid);
161}
162
163/* Fuzzer entry point */
164extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
165{
166    if (data == nullptr) {
167        return 0;
168    }
169    sleep(DHCP_SLEEP_1);
170    OHOS::DHCP::Ip4StrConToIntTest(data, size);
171    OHOS::DHCP::Ip4IntConvertToStrTest(data, size);
172    OHOS::DHCP::Ip6StrConToCharTest(data, size);
173    OHOS::DHCP::CheckIpStrTest(data, size);
174    OHOS::DHCP::IsExistFileTest(data, size);
175    OHOS::DHCP::CreateFileTest(data, size);
176    OHOS::DHCP::RemoveFileTest(data, size);
177    OHOS::DHCP::AddFileLineDataTest(data, size);
178    OHOS::DHCP::DelFileLineDataTest(data, size);
179    OHOS::DHCP::ModifyFileLineDataTest(data, size);
180    OHOS::DHCP::FormatStringTest(data, size);
181    OHOS::DHCP::InitPidfileTest(data, size);
182    OHOS::DHCP::GetPIDTest(data, size);
183    OHOS::DHCP::CheckProRunningTest(data, size);
184    OHOS::DHCP::CreateDirsTest(data, size);
185    OHOS::DHCP::SplitStringTest(data, size);
186    OHOS::DHCP::WaitProcessExitTest(data, size);
187    return 0;
188}
189}  // namespace DHCP
190}  // namespace OHOS
191