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