1 /*
2  * Copyright (C) 2021-2022 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 <gtest/gtest.h>
17 
18 #include "dhcp_logger.h"
19 #include "dhcp_socket.h"
20 #include "dhcp_function.h"
21 #include "securec.h"
22 #include "mock_system_func.h"
23 
24 DEFINE_DHCPLOG_DHCP_LABEL("DhcpSocketTest");
25 
26 using namespace testing::ext;
27 using namespace OHOS::DHCP;
28 
29 namespace OHOS {
30 class DhcpSocketTest : public testing::Test {
31 public:
SetUpTestCase()32     static void SetUpTestCase()
33     {}
TearDownTestCase()34     static void TearDownTestCase()
35     {}
SetUp()36     virtual void SetUp()
37     {}
TearDown()38     virtual void TearDown()
39     {}
40 };
41 
HWTEST_F(DhcpSocketTest, CreateRawSocket_SUCCESS, TestSize.Level1)42 HWTEST_F(DhcpSocketTest, CreateRawSocket_SUCCESS, TestSize.Level1)
43 {
44     DHCP_LOGE("enter CreateRawSocket_SUCCESS");
45     MockSystemFunc::SetMockFlag(true);
46 
47     EXPECT_CALL(MockSystemFunc::GetInstance(), socket(_, _, _)).WillOnce(Return(-1)).WillRepeatedly(Return(1));
48     int fd = -1;
49     EXPECT_EQ(CreateRawSocket(&fd), SOCKET_OPT_FAILED);
50     EXPECT_EQ(CreateRawSocket(&fd), SOCKET_OPT_SUCCESS);
51 
52     MockSystemFunc::SetMockFlag(false);
53 }
54 
HWTEST_F(DhcpSocketTest, CreateKernelSocket_SUCCESS, TestSize.Level1)55 HWTEST_F(DhcpSocketTest, CreateKernelSocket_SUCCESS, TestSize.Level1)
56 {
57     MockSystemFunc::SetMockFlag(true);
58 
59     EXPECT_CALL(MockSystemFunc::GetInstance(), socket(_, _, _)).WillOnce(Return(-1)).WillRepeatedly(Return(1));
60     EXPECT_CALL(MockSystemFunc::GetInstance(), close(_)).WillRepeatedly(Return(0));
61     int fd = -1;
62     EXPECT_EQ(CreateKernelSocket(nullptr), SOCKET_OPT_FAILED);
63     EXPECT_EQ(CreateKernelSocket(&fd), SOCKET_OPT_FAILED);
64     EXPECT_EQ(CreateKernelSocket(&fd), SOCKET_OPT_SUCCESS);
65 
66     MockSystemFunc::SetMockFlag(false);
67 }
68 
HWTEST_F(DhcpSocketTest, BindRawSocket_SUCCESS, TestSize.Level1)69 HWTEST_F(DhcpSocketTest, BindRawSocket_SUCCESS, TestSize.Level1)
70 {
71     int fd = -1;
72     int ifaceIndex = 1;
73     EXPECT_EQ(BindRawSocket(fd, ifaceIndex, NULL), SOCKET_OPT_FAILED);
74 
75     MockSystemFunc::SetMockFlag(true);
76 
77     fd = 1;
78     EXPECT_CALL(MockSystemFunc::GetInstance(), bind(_, _, _)).WillOnce(Return(-1)).WillRepeatedly(Return(0));
79     EXPECT_EQ(BindRawSocket(fd, ifaceIndex, (uint8_t *)MAC_BCAST_ADDR), SOCKET_OPT_FAILED);
80     EXPECT_EQ(BindRawSocket(fd, ifaceIndex, (uint8_t *)MAC_BCAST_ADDR), SOCKET_OPT_SUCCESS);
81 
82     MockSystemFunc::SetMockFlag(false);
83 }
84 
HWTEST_F(DhcpSocketTest, BindKernelSocket_SUCCESS, TestSize.Level1)85 HWTEST_F(DhcpSocketTest, BindKernelSocket_SUCCESS, TestSize.Level1)
86 {
87     int fd = -1;
88     EXPECT_EQ(BindKernelSocket(fd, NULL, 0, 0, false), SOCKET_OPT_FAILED);
89 
90     MockSystemFunc::SetMockFlag(true);
91 
92     fd = 1;
93     const char *ifname = "wlan0";
94     EXPECT_CALL(MockSystemFunc::GetInstance(), setsockopt(_, _, _, _, _))
95         .WillOnce(Return(-1))
96         .WillOnce(Return(-1))
97         .WillOnce(Return(-1)).WillRepeatedly(Return(0));
98     EXPECT_CALL(MockSystemFunc::GetInstance(), bind(_, _, _)).WillOnce(Return(-1)).WillRepeatedly(Return(0));
99     EXPECT_CALL(MockSystemFunc::GetInstance(), close(_)).WillRepeatedly(Return(0));
100 
101     EXPECT_EQ(BindKernelSocket(fd, ifname, 0, 0, false), SOCKET_OPT_FAILED);
102     EXPECT_EQ(BindKernelSocket(fd, NULL, 0, 0, true), SOCKET_OPT_FAILED);
103     EXPECT_EQ(BindKernelSocket(fd, NULL, 0, 0, false), SOCKET_OPT_FAILED);
104     EXPECT_EQ(BindKernelSocket(fd, NULL, INADDR_ANY, BOOTP_CLIENT, false), SOCKET_OPT_FAILED);
105     EXPECT_EQ(BindKernelSocket(fd, ifname, INADDR_ANY, BOOTP_CLIENT, true), SOCKET_OPT_SUCCESS);
106 
107     MockSystemFunc::SetMockFlag(false);
108 }
109 
HWTEST_F(DhcpSocketTest, SendToDhcpPacket_SUCCESS, TestSize.Level1)110 HWTEST_F(DhcpSocketTest, SendToDhcpPacket_SUCCESS, TestSize.Level1)
111 {
112     uint32_t srcIp = 3226272232;
113     uint32_t destIp = 3226272232;
114     int destIndex = 1;
115     uint8_t destHwaddr[6] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55};
116 
117     struct DhcpPacket packet;
118     ASSERT_TRUE(memset_s(&packet, sizeof(struct DhcpPacket), 0, sizeof(struct DhcpPacket)) == EOK);
119 
120     int endIndex = 0;
121     uint8_t *pOption = packet.options;
122     pOption[endIndex + DHCP_OPT_CODE_INDEX] = PAD_OPTION;
123     endIndex += DHCP_OPT_CODE_BYTES;
124 
125     pOption[endIndex + DHCP_OPT_CODE_INDEX] = SUBNET_MASK_OPTION;
126     pOption[endIndex + DHCP_OPT_LEN_INDEX] = DHCP_UINT32_BYTES;
127     uint32_t u32Data = 3226272231;
128     ASSERT_TRUE(
129         memcpy_s(pOption + endIndex + DHCP_OPT_DATA_INDEX, DHCP_UINT32_BYTES, &u32Data, DHCP_UINT32_BYTES) == EOK);
130     endIndex += DHCP_OPT_CODE_BYTES + DHCP_OPT_LEN_BYTES + pOption[endIndex + DHCP_OPT_LEN_INDEX];
131 
132     pOption[endIndex + DHCP_OPT_CODE_INDEX] = END_OPTION;
133 
134     int result = SendToDhcpPacket(&packet, srcIp, destIp, destIndex, destHwaddr);
135     EXPECT_EQ(result, 0);
136 }
137 
HWTEST_F(DhcpSocketTest, SendDhcpPacket_SUCCESS, TestSize.Level1)138 HWTEST_F(DhcpSocketTest, SendDhcpPacket_SUCCESS, TestSize.Level1)
139 {
140     MockSystemFunc::SetMockFlag(true);
141 
142     EXPECT_CALL(MockSystemFunc::GetInstance(), socket(_, _, _)).WillOnce(Return(-1)).WillRepeatedly(Return(1));
143     EXPECT_CALL(MockSystemFunc::GetInstance(), bind(_, _, _)).WillOnce(Return(-1)).WillRepeatedly(Return(0));
144     EXPECT_CALL(MockSystemFunc::GetInstance(), connect(_, _, _)).WillOnce(Return(-1)).WillRepeatedly(Return(0));
145     EXPECT_CALL(MockSystemFunc::GetInstance(), write(_, _, _)).WillOnce(Return(-1)).WillRepeatedly(Return(1));
146     EXPECT_CALL(MockSystemFunc::GetInstance(), close(_)).WillRepeatedly(Return(0));
147 
148     EXPECT_EQ(SendDhcpPacket(NULL, 0, 0), SOCKET_OPT_FAILED);
149     EXPECT_EQ(SendDhcpPacket(NULL, INADDR_ANY, 0), SOCKET_OPT_FAILED);
150     EXPECT_EQ(SendDhcpPacket(NULL, INADDR_ANY, INADDR_BROADCAST), SOCKET_OPT_FAILED);
151     struct DhcpPacket packet;
152     packet.xid = 123456;
153     EXPECT_EQ(SendDhcpPacket(&packet, INADDR_ANY, INADDR_BROADCAST), SOCKET_OPT_SUCCESS);
154     MockSystemFunc::SetMockFlag(false);
155 }
156 
HWTEST_F(DhcpSocketTest, CheckReadBytes_SUCCESS, TestSize.Level1)157 HWTEST_F(DhcpSocketTest, CheckReadBytes_SUCCESS, TestSize.Level1)
158 {
159     int count = -1;
160     int total = 0;
161     EXPECT_EQ(CheckReadBytes(-1, 0), SOCKET_OPT_ERROR);
162 
163     count = sizeof(struct iphdr) + sizeof(struct udphdr) - 1;
164     EXPECT_EQ(CheckReadBytes(count, 0), SOCKET_OPT_FAILED);
165 
166     count = sizeof(struct iphdr) + sizeof(struct udphdr);
167     total = count + 1;
168     EXPECT_EQ(CheckReadBytes(count, total), SOCKET_OPT_FAILED);
169 
170     total = count;
171     EXPECT_EQ(CheckReadBytes(count, total), SOCKET_OPT_SUCCESS);
172 }
173 
HWTEST_F(DhcpSocketTest, CheckUdpPacket_SUCCESS, TestSize.Level1)174 HWTEST_F(DhcpSocketTest, CheckUdpPacket_SUCCESS, TestSize.Level1)
175 {
176     EXPECT_EQ(CheckUdpPacket(NULL, 0), SOCKET_OPT_FAILED);
177 
178     struct UdpDhcpPacket packet;
179     int total = (int)sizeof(struct UdpDhcpPacket) + 1;
180     EXPECT_EQ(CheckUdpPacket(&packet, total), SOCKET_OPT_FAILED);
181 
182     total = (int)sizeof(struct UdpDhcpPacket);
183     packet.ip.protocol = 0;
184     packet.ip.version = 0;
185     EXPECT_EQ(CheckUdpPacket(&packet, total), SOCKET_OPT_FAILED);
186 
187     packet.ip.protocol = IPPROTO_UDP;
188     packet.ip.version = IPVERSION;
189     packet.ip.ihl = 0;
190     EXPECT_EQ(CheckUdpPacket(&packet, total), SOCKET_OPT_FAILED);
191 
192     packet.ip.ihl = (uint32_t)(sizeof(packet.ip) >> DHCP_UINT16_BYTES);
193     packet.udp.dest = 0;
194     EXPECT_EQ(CheckUdpPacket(&packet, total), SOCKET_OPT_FAILED);
195 
196     packet.udp.dest = htons(BOOTP_CLIENT);
197     packet.udp.len = 0;
198     EXPECT_EQ(CheckUdpPacket(&packet, total), SOCKET_OPT_FAILED);
199 
200     uint16_t uLen = (uint16_t)(total - (int)sizeof(packet.ip));
201     packet.udp.len = htons(uLen);
202     EXPECT_EQ(CheckUdpPacket(&packet, total), SOCKET_OPT_SUCCESS);
203 }
204 
HWTEST_F(DhcpSocketTest, CheckPacketIpSum_FAILED, TestSize.Level1)205 HWTEST_F(DhcpSocketTest, CheckPacketIpSum_FAILED, TestSize.Level1)
206 {
207     EXPECT_EQ(CheckPacketIpSum(NULL, 0), SOCKET_OPT_FAILED);
208 
209     struct UdpDhcpPacket packet;
210     int total = (int)sizeof(struct UdpDhcpPacket) + 1;
211     EXPECT_EQ(CheckPacketIpSum(&packet, total), SOCKET_OPT_FAILED);
212 
213     total = (int)sizeof(struct UdpDhcpPacket);
214     packet.ip.protocol = IPPROTO_UDP;
215     packet.ip.version = IPVERSION;
216     packet.ip.ihl = (uint32_t)(sizeof(packet.ip) >> DHCP_UINT16_BYTES);
217     packet.udp.dest = htons(BOOTP_CLIENT);
218     uint16_t uLen = (uint16_t)(total - (int)sizeof(packet.ip));
219     packet.udp.len = htons(uLen);
220     packet.ip.check = 0;
221     EXPECT_EQ(CheckPacketIpSum(&packet, total), SOCKET_OPT_ERROR);
222 }
223 
HWTEST_F(DhcpSocketTest, CheckPacketUdpSum_SUCCESS, TestSize.Level1)224 HWTEST_F(DhcpSocketTest, CheckPacketUdpSum_SUCCESS, TestSize.Level1)
225 {
226     EXPECT_EQ(CheckPacketUdpSum(NULL, 0), SOCKET_OPT_FAILED);
227 
228     struct UdpDhcpPacket packet;
229     packet.udp.check = 1;
230     EXPECT_EQ(CheckPacketUdpSum(&packet, 0), SOCKET_OPT_FAILED);
231     packet.udp.check = 0;
232     EXPECT_EQ(CheckPacketUdpSum(&packet, 1), SOCKET_OPT_SUCCESS);
233 }
234 
HWTEST_F(DhcpSocketTest, GetDhcpKernelPacket_SUCCESS, TestSize.Level1)235 HWTEST_F(DhcpSocketTest, GetDhcpKernelPacket_SUCCESS, TestSize.Level1)
236 {
237     EXPECT_EQ(GetDhcpKernelPacket(NULL, 0), SOCKET_OPT_FAILED);
238 
239     MockSystemFunc::SetMockFlag(true);
240 
241     EXPECT_CALL(MockSystemFunc::GetInstance(), read(_, _, _)).WillOnce(Return(-1)).WillRepeatedly(Return(1));
242 
243     struct DhcpPacket packet;
244     EXPECT_EQ(GetDhcpKernelPacket(&packet, 1), SOCKET_OPT_ERROR);
245 
246     packet.cookie = htonl(MAGIC_COOKIE);
247     EXPECT_EQ(GetDhcpKernelPacket(&packet, 1), SOCKET_OPT_ERROR);
248 
249     MockSystemFunc::SetMockFlag(false);
250 }
251 
HWTEST_F(DhcpSocketTest, GetDhcpRawPacket_FAILED, TestSize.Level1)252 HWTEST_F(DhcpSocketTest, GetDhcpRawPacket_FAILED, TestSize.Level1)
253 {
254     EXPECT_EQ(GetDhcpRawPacket(NULL, 1), SOCKET_OPT_FAILED);
255 
256     struct DhcpPacket packet;
257     EXPECT_EQ(GetDhcpRawPacket(&packet, 1), SOCKET_OPT_ERROR);
258 }
259 }  // namespace OHOS