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 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 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 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 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 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 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_FAILED); 154 EXPECT_EQ(SendDhcpPacket(&packet, INADDR_ANY, INADDR_BROADCAST), SOCKET_OPT_SUCCESS); 155 MockSystemFunc::SetMockFlag(false); 156 } 157 158 HWTEST_F(DhcpSocketTest, CheckReadBytes_SUCCESS, TestSize.Level1) 159 { 160 int count = -1; 161 int total = 0; 162 EXPECT_EQ(CheckReadBytes(-1, 0), SOCKET_OPT_ERROR); 163 164 count = sizeof(struct iphdr) + sizeof(struct udphdr) - 1; 165 EXPECT_EQ(CheckReadBytes(count, 0), SOCKET_OPT_FAILED); 166 167 count = sizeof(struct iphdr) + sizeof(struct udphdr); 168 total = count + 1; 169 EXPECT_EQ(CheckReadBytes(count, total), SOCKET_OPT_FAILED); 170 171 total = count; 172 EXPECT_EQ(CheckReadBytes(count, total), SOCKET_OPT_SUCCESS); 173 } 174 175 HWTEST_F(DhcpSocketTest, CheckUdpPacket_SUCCESS, TestSize.Level1) 176 { 177 EXPECT_EQ(CheckUdpPacket(NULL, 0), SOCKET_OPT_FAILED); 178 179 struct UdpDhcpPacket packet; 180 int total = (int)sizeof(struct UdpDhcpPacket) + 1; 181 EXPECT_EQ(CheckUdpPacket(&packet, total), SOCKET_OPT_FAILED); 182 183 total = (int)sizeof(struct UdpDhcpPacket); 184 packet.ip.protocol = 0; 185 packet.ip.version = 0; 186 EXPECT_EQ(CheckUdpPacket(&packet, total), SOCKET_OPT_FAILED); 187 188 packet.ip.protocol = IPPROTO_UDP; 189 packet.ip.version = IPVERSION; 190 packet.ip.ihl = 0; 191 EXPECT_EQ(CheckUdpPacket(&packet, total), SOCKET_OPT_FAILED); 192 193 packet.ip.ihl = (uint32_t)(sizeof(packet.ip) >> DHCP_UINT16_BYTES); 194 packet.udp.dest = 0; 195 EXPECT_EQ(CheckUdpPacket(&packet, total), SOCKET_OPT_FAILED); 196 197 packet.udp.dest = htons(BOOTP_CLIENT); 198 packet.udp.len = 0; 199 EXPECT_EQ(CheckUdpPacket(&packet, total), SOCKET_OPT_FAILED); 200 201 uint16_t uLen = (uint16_t)(total - (int)sizeof(packet.ip)); 202 packet.udp.len = htons(uLen); 203 EXPECT_EQ(CheckUdpPacket(&packet, total), SOCKET_OPT_SUCCESS); 204 } 205 206 HWTEST_F(DhcpSocketTest, CheckPacketIpSum_FAILED, TestSize.Level1) 207 { 208 EXPECT_EQ(CheckPacketIpSum(NULL, 0), SOCKET_OPT_FAILED); 209 210 struct UdpDhcpPacket packet; 211 int total = (int)sizeof(struct UdpDhcpPacket) + 1; 212 EXPECT_EQ(CheckPacketIpSum(&packet, total), SOCKET_OPT_FAILED); 213 214 total = (int)sizeof(struct UdpDhcpPacket); 215 packet.ip.protocol = IPPROTO_UDP; 216 packet.ip.version = IPVERSION; 217 packet.ip.ihl = (uint32_t)(sizeof(packet.ip) >> DHCP_UINT16_BYTES); 218 packet.udp.dest = htons(BOOTP_CLIENT); 219 uint16_t uLen = (uint16_t)(total - (int)sizeof(packet.ip)); 220 packet.udp.len = htons(uLen); 221 packet.ip.check = 0; 222 EXPECT_EQ(CheckPacketIpSum(&packet, total), SOCKET_OPT_ERROR); 223 } 224 225 HWTEST_F(DhcpSocketTest, CheckPacketUdpSum_SUCCESS, TestSize.Level1) 226 { 227 EXPECT_EQ(CheckPacketUdpSum(NULL, 0), SOCKET_OPT_FAILED); 228 229 struct UdpDhcpPacket packet; 230 packet.udp.check = 1; 231 EXPECT_EQ(CheckPacketUdpSum(&packet, 0), SOCKET_OPT_FAILED); 232 packet.udp.check = 0; 233 EXPECT_EQ(CheckPacketUdpSum(&packet, 1), SOCKET_OPT_SUCCESS); 234 } 235 236 HWTEST_F(DhcpSocketTest, GetDhcpKernelPacket_SUCCESS, TestSize.Level1) 237 { 238 EXPECT_EQ(GetDhcpKernelPacket(NULL, 0), SOCKET_OPT_FAILED); 239 240 MockSystemFunc::SetMockFlag(true); 241 242 EXPECT_CALL(MockSystemFunc::GetInstance(), read(_, _, _)).WillOnce(Return(-1)).WillRepeatedly(Return(1)); 243 244 struct DhcpPacket packet; 245 EXPECT_EQ(GetDhcpKernelPacket(&packet, 1), SOCKET_OPT_ERROR); 246 EXPECT_EQ(GetDhcpKernelPacket(&packet, 1), SOCKET_OPT_FAILED); 247 248 packet.cookie = htonl(MAGIC_COOKIE); 249 EXPECT_GT(GetDhcpKernelPacket(&packet, 1), 0); 250 251 MockSystemFunc::SetMockFlag(false); 252 } 253 254 HWTEST_F(DhcpSocketTest, GetDhcpRawPacket_FAILED, TestSize.Level1) 255 { 256 EXPECT_EQ(GetDhcpRawPacket(NULL, 1), SOCKET_OPT_FAILED); 257 258 struct DhcpPacket packet; 259 EXPECT_EQ(GetDhcpRawPacket(&packet, 1), SOCKET_OPT_ERROR); 260 } 261 } // namespace OHOS