1 /* 2 * Copyright (C) 2021 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 #include <stdint.h> 18 #include <stdbool.h> 19 #include "dhcp_define.h" 20 #include "dhcp_ipv4.h" 21 #include "dhcp_message.h" 22 #include "dhcp_option.h" 23 #include "dhcp_address_pool.h" 24 #include "address_utils.h" 25 #include "common_util.h" 26 #include "securec.h" 27 28 using namespace testing::ext; 29 30 class DhcpAddressPoolTest : public testing::Test { 31 public: SetUpTestCase()32 static void SetUpTestCase() 33 {} TearDownTestCase()34 static void TearDownTestCase() 35 {} SetUp()36 virtual void SetUp() 37 { 38 if (InitAddressPool(&testPool, "lo", NULL)) { 39 printf("failed to initialized address pool.\n"); 40 } 41 } TearDown()42 virtual void TearDown() 43 { 44 ResetPollConfig(); 45 FreeAddressPool(&testPool); 46 } 47 SamplePoolConfig()48 bool SamplePoolConfig() 49 { 50 uint32_t beginIp = ParseIpAddr("192.168.100.100"); 51 uint32_t endIp = ParseIpAddr("192.168.100.150"); 52 uint32_t netmask = ParseIpAddr("255.255.255.0"); 53 uint32_t gateway = ParseIpAddr("192.168.100.254"); 54 uint32_t serverId = ParseIpAddr("192.168.100.1"); 55 if (beginIp != 0 && endIp != 0 && netmask != 0 && gateway != 0) { 56 testPool.addressRange.beginAddress = beginIp; 57 testPool.addressRange.endAddress = endIp; 58 testPool.netmask = netmask; 59 testPool.gateway = gateway; 60 testPool.serverId = serverId; 61 testPool.leaseTime = DHCP_LEASE_TIME; 62 return true; 63 } 64 return false; 65 } 66 ResetPollConfig()67 void ResetPollConfig() 68 { 69 testPool.addressRange.beginAddress = 0; 70 testPool.addressRange.endAddress = 0; 71 testPool.netmask = 0; 72 testPool.gateway = 0; 73 testPool.serverId = 0; 74 testPool.leaseTime = 0; 75 } 76 77 public: 78 DhcpAddressPool testPool; 79 80 }; 81 82 HWTEST_F(DhcpAddressPoolTest, AddBindingTest, TestSize.Level1) 83 { 84 AddressBinding bind = {0}; 85 uint8_t testMac1[DHCP_HWADDR_LENGTH] = {0x00, 0x0e, 0x3c, 0x65, 0x3a, 0x09, 0}; 86 uint8_t testMac2[DHCP_HWADDR_LENGTH] = {0x00, 0x0e, 0x3c, 0x65, 0x3a, 0x0a, 0}; 87 uint32_t testIp1 = ParseIpAddr("192.168.100.1"); 88 uint32_t testIp2 = ParseIpAddr("192.168.100.2"); 89 bind.ipAddress = testIp1; 90 for (int i = 0; i < MAC_ADDR_LENGTH; ++i) { 91 bind.chaddr[i] = testMac1[i]; 92 } 93 EXPECT_EQ(RET_SUCCESS, AddBinding(&bind)); 94 bind.ipAddress = testIp2; 95 for (int i = 0; i < MAC_ADDR_LENGTH; ++i) { 96 bind.chaddr[i] = testMac2[i]; 97 } 98 99 EXPECT_EQ(RET_ERROR, AddBinding(NULL)); 100 EXPECT_EQ(RET_SUCCESS, AddBinding(&bind)); 101 EXPECT_EQ(RET_FAILED, AddBinding(&bind)); 102 EXPECT_TRUE(memset_s(bind.chaddr, sizeof(bind.chaddr), 0, sizeof(bind.chaddr)) == EOK); 103 EXPECT_EQ(RET_SUCCESS, RemoveBinding(testMac1)); 104 EXPECT_EQ(RET_SUCCESS, RemoveBinding(testMac2)); 105 } 106 107 HWTEST_F(DhcpAddressPoolTest, AddNewBindingTest, TestSize.Level1) 108 { 109 uint8_t testMac1[DHCP_HWADDR_LENGTH] = {0x00, 0x0e, 0x3c, 0x65, 0x3a, 0x09, 0}; 110 ASSERT_TRUE(testPool.newBinding != NULL); 111 ASSERT_TRUE(testPool.newBinding(testMac1, NULL) != NULL); 112 EXPECT_EQ(RET_SUCCESS, RemoveBinding(testMac1)); 113 } 114 115 HWTEST_F(DhcpAddressPoolTest, FindBindingByIpTest, TestSize.Level1) 116 { 117 AddressBinding bind = {0}; 118 uint8_t testMac1[DHCP_HWADDR_LENGTH] = {0x00, 0x0e, 0x3c, 0x65, 0x3a, 0x09, 0}; 119 uint8_t testMac2[DHCP_HWADDR_LENGTH] = {0x00, 0x0e, 0x3c, 0x65, 0x3a, 0x0a, 0}; 120 uint32_t testIp1 = ParseIpAddr("192.168.100.1"); 121 uint32_t testIp2 = ParseIpAddr("192.168.100.2"); 122 bind.ipAddress = testIp1; 123 for (int i = 0; i < MAC_ADDR_LENGTH; ++i) { 124 bind.chaddr[i] = testMac1[i]; 125 } 126 EXPECT_EQ(RET_SUCCESS, AddBinding(&bind)); 127 bind.ipAddress = testIp2; 128 for (int i = 0; i < MAC_ADDR_LENGTH; ++i) { 129 bind.chaddr[i] = testMac2[i]; 130 } 131 EXPECT_EQ(RET_SUCCESS, AddBinding(&bind)); 132 EXPECT_EQ(RET_FAILED, AddBinding(&bind)); 133 134 AddressBinding *pBind1 = FindBindingByIp(testIp1); 135 AddressBinding *pBind2 = FindBindingByIp(testIp2); 136 EXPECT_TRUE(pBind1 != NULL); 137 EXPECT_TRUE(pBind2 != NULL); 138 if (pBind1 != NULL) { 139 EXPECT_EQ(testIp1, pBind1->ipAddress); 140 } 141 EXPECT_EQ(RET_SUCCESS, RemoveBinding(testMac1)); 142 EXPECT_EQ(RET_SUCCESS, RemoveBinding(testMac2)); 143 } 144 145 HWTEST_F(DhcpAddressPoolTest, AddressDistributeTest, TestSize.Level1) 146 { 147 uint8_t testMac1[DHCP_HWADDR_LENGTH] = {0x01, 0x0e, 0x3c, 0x65, 0x3a, 0x09, 0}; 148 uint8_t testMac2[DHCP_HWADDR_LENGTH] = {0x01, 0x0e, 0x3c, 0x65, 0x3a, 0x0a, 0}; 149 uint8_t testMac3[DHCP_HWADDR_LENGTH] = {0x01, 0x0e, 0x3c, 0x65, 0x3a, 0x09, 0}; 150 151 EXPECT_TRUE(testPool.distribue(NULL, testMac1) == 0); 152 EXPECT_TRUE(testPool.distribue(&testPool, testMac1) == 0); 153 ASSERT_TRUE(SamplePoolConfig()); 154 SetDistributeMode(0); 155 EXPECT_EQ(0, GetDistributeMode()); 156 uint32_t assertAddr = ParseIpAddr("192.168.100.101"); 157 EXPECT_EQ(assertAddr, testPool.distribue(&testPool, testMac1)); 158 assertAddr = ParseIpAddr("192.168.100.102"); 159 EXPECT_EQ(assertAddr, testPool.distribue(&testPool, testMac2)); 160 assertAddr = ParseIpAddr("192.168.100.103"); 161 EXPECT_EQ(assertAddr, testPool.distribue(&testPool, testMac3)); 162 } 163 164 HWTEST_F(DhcpAddressPoolTest, IsReservedTest, TestSize.Level1) 165 { 166 AddressBinding bind = {0}; 167 uint8_t testMac1[DHCP_HWADDR_LENGTH] = {0x00, 0x0e, 0x3c, 0x65, 0x3a, 0x09, 0}; 168 uint8_t testMac2[DHCP_HWADDR_LENGTH] = {0x00, 0x0e, 0x3c, 0x65, 0x3a, 0x0a, 0}; 169 uint8_t testMac3[DHCP_HWADDR_LENGTH] = {0x00, 0x0e, 0x3c, 0x65, 0x3a, 0x0b, 0}; 170 uint32_t testIp1 = ParseIpAddr("192.168.100.1"); 171 ASSERT_TRUE(testIp1 != 0); 172 uint32_t testIp2 = ParseIpAddr("192.168.100.2"); 173 ASSERT_TRUE(testIp2 != 0); 174 bind.ipAddress = testIp1; 175 for (int i = 0; i < MAC_ADDR_LENGTH; ++i) { 176 bind.chaddr[i] = testMac1[i]; 177 } 178 EXPECT_EQ(RET_SUCCESS, AddBinding(&bind)); 179 bind.ipAddress = testIp2; 180 for (int i = 0; i < MAC_ADDR_LENGTH; ++i) { 181 bind.chaddr[i] = testMac2[i]; 182 } 183 EXPECT_EQ(RET_SUCCESS, AddReservedBinding(testMac2)); 184 EXPECT_EQ(RET_SUCCESS, AddReservedBinding(testMac2)); 185 EXPECT_EQ(RET_FAILED, AddBinding(&bind)); 186 EXPECT_EQ(0, IsReserved(testMac1)); 187 EXPECT_EQ(1, IsReserved(testMac2)); 188 for (int i = 0; i < MAC_ADDR_LENGTH; ++i) { 189 bind.chaddr[i] = testMac3[i]; 190 } 191 EXPECT_EQ(0, IsReserved(testMac3)); 192 EXPECT_EQ(RET_SUCCESS, RemoveBinding(testMac1)); 193 EXPECT_EQ(RET_SUCCESS, RemoveBinding(testMac2)); 194 } 195 196 197 HWTEST_F(DhcpAddressPoolTest, IsReservedIpTest, TestSize.Level1) 198 { 199 AddressBinding bind = {0}; 200 bind.bindingMode = BIND_MODE_DYNAMIC; 201 uint8_t testMac1[DHCP_HWADDR_LENGTH] = {0x00, 0x0e, 0x3c, 0x65, 0x3a, 0x09, 0}; 202 uint8_t testMac2[DHCP_HWADDR_LENGTH] = {0x00, 0x0e, 0x3c, 0x65, 0x3a, 0x0a, 0}; 203 uint32_t testIp1 = ParseIpAddr("192.168.100.1"); 204 ASSERT_TRUE(testIp1 != 0); 205 uint32_t testIp2 = ParseIpAddr("192.168.100.2"); 206 ASSERT_TRUE(testIp2 != 0); 207 bind.ipAddress = testIp1; 208 for (int i = 0; i < MAC_ADDR_LENGTH; ++i) { 209 bind.chaddr[i] = testMac1[i]; 210 } 211 EXPECT_EQ(RET_SUCCESS, AddLease(&testPool, &bind)); 212 bind.ipAddress = testIp2; 213 for (int i = 0; i < MAC_ADDR_LENGTH; ++i) { 214 bind.chaddr[i] = testMac2[i]; 215 } 216 bind.bindingMode = BIND_MODE_RESERVED; 217 EXPECT_EQ(RET_SUCCESS, AddLease(&testPool, &bind)); 218 EXPECT_EQ(0, IsReservedIp(&testPool, testIp1)); 219 EXPECT_EQ(1, IsReservedIp(&testPool, testIp2)); 220 EXPECT_EQ(DHCP_FALSE, IsReservedIp(NULL, testIp1)); 221 EXPECT_EQ(DHCP_FALSE, IsReservedIp(&testPool, 0)); 222 bind.ipAddress = testIp1; 223 EXPECT_EQ(RET_SUCCESS, RemoveLease(&testPool, &bind)); 224 bind.ipAddress = testIp2; 225 EXPECT_EQ(RET_SUCCESS, RemoveLease(&testPool, &bind)); 226 } 227 228 HWTEST_F(DhcpAddressPoolTest, RemoveReservedBindingTest, TestSize.Level1) 229 { 230 AddressBinding bind = {0}, bind2 = {0}; 231 uint8_t testMac1[DHCP_HWADDR_LENGTH] = {0x00, 0x01, 0x3c, 0x65, 0x3a, 0x09, 0}; 232 uint8_t testMac2[DHCP_HWADDR_LENGTH] = {0x00, 0x02, 0x3c, 0x65, 0x3a, 0x0a, 0}; 233 uint8_t testMac3[DHCP_HWADDR_LENGTH] = {0x00, 0x03, 0x3c, 0x65, 0x3a, 0x0b, 0}; 234 uint8_t testMac4[DHCP_HWADDR_LENGTH] = {0x00, 0x03, 0x3c, 0x65, 0x3a, 0x0c, 0}; 235 uint32_t testIp1 = ParseIpAddr("192.168.100.1"); 236 EXPECT_TRUE(testIp1 != 0); 237 uint32_t testIp2 = ParseIpAddr("192.168.100.2"); 238 EXPECT_TRUE(testIp2 != 0); 239 bind.ipAddress = testIp1; 240 for (int i = 0; i < MAC_ADDR_LENGTH; ++i) { 241 bind.chaddr[i] = testMac1[i]; 242 } 243 EXPECT_EQ(RET_SUCCESS, AddBinding(&bind)); 244 bind2.ipAddress = testIp2; 245 for (int i = 0; i < MAC_ADDR_LENGTH; ++i) { 246 bind2.chaddr[i] = testMac2[i]; 247 } 248 bind2.bindingMode = BIND_MODE_RESERVED; 249 ASSERT_EQ(RET_SUCCESS, AddBinding(&bind2)); 250 EXPECT_EQ(RET_FAILED, RemoveReservedBinding(testMac1)); 251 EXPECT_EQ(RET_SUCCESS, RemoveBinding(testMac1)); 252 AddressBinding *binding = QueryBinding(testMac2, NULL); 253 ASSERT_TRUE(binding != NULL); 254 EXPECT_EQ(RET_SUCCESS, RemoveReservedBinding(testMac2)); 255 EXPECT_EQ(RET_FAILED, RemoveReservedBinding(testMac2)); 256 EXPECT_EQ(RET_FAILED, RemoveReservedBinding(testMac3)); 257 EXPECT_EQ(RET_FAILED, RemoveReservedBinding(testMac4)); 258 } 259 260 HWTEST_F(DhcpAddressPoolTest, ReleaseBindingTest, TestSize.Level1) 261 { 262 AddressBinding bind = {0}; 263 bind.bindingMode = BIND_ASSOCIATED; 264 uint8_t testMac1[DHCP_HWADDR_LENGTH] = {0x00, 0x0e, 0x3c, 0x65, 0x3a, 0x09, 0}; 265 uint8_t testMac2[DHCP_HWADDR_LENGTH] = {0x00, 0x0e, 0x3c, 0x65, 0x3a, 0x0a, 0}; 266 uint8_t testMac3[DHCP_HWADDR_LENGTH] = {0x00, 0x0e, 0x3c, 0x65, 0x3a, 0x0b, 0}; 267 uint32_t testIp1 = ParseIpAddr("192.168.100.1"); 268 ASSERT_TRUE(testIp1 != 0); 269 uint32_t testIp2 = ParseIpAddr("192.168.100.2"); 270 ASSERT_TRUE(testIp2 != 0); 271 bind.ipAddress = testIp1; 272 for (int i = 0; i < MAC_ADDR_LENGTH; ++i) { 273 bind.chaddr[i] = testMac1[i]; 274 } 275 ASSERT_EQ(RET_SUCCESS, AddBinding(&bind)); 276 bind.ipAddress = testIp2; 277 for (int i = 0; i < MAC_ADDR_LENGTH; ++i) { 278 bind.chaddr[i] = testMac2[i]; 279 } 280 ASSERT_EQ(RET_SUCCESS, AddBinding(&bind)); 281 EXPECT_EQ(RET_SUCCESS, ReleaseBinding(testMac1)); 282 EXPECT_EQ(RET_FAILED, ReleaseBinding(testMac3)); 283 EXPECT_EQ(RET_SUCCESS, RemoveBinding(testMac1)); 284 EXPECT_EQ(RET_SUCCESS, RemoveBinding(testMac2)); 285 } 286 287 HWTEST_F(DhcpAddressPoolTest, AddLeaseTest, TestSize.Level1) 288 { 289 AddressBinding lease = {0}; 290 lease.bindingMode = BIND_MODE_DYNAMIC; 291 lease.bindingStatus = BIND_ASSOCIATED; 292 uint8_t testMac1[DHCP_HWADDR_LENGTH] = {0x01, 0x0e, 0x3c, 0x65, 0x3a, 0x09, 0}; 293 uint8_t testMac2[DHCP_HWADDR_LENGTH] = {0x01, 0x0e, 0x3d, 0x65, 0x3a, 0x0a, 0}; 294 uint32_t testIp1 = ParseIpAddr("192.168.100.101"); 295 ASSERT_TRUE(testIp1 != 0); 296 lease.ipAddress = testIp1; 297 lease.leaseTime = DHCP_LEASE_TIME; 298 lease.pendingTime = 1631240659; 299 lease.bindingTime = 1631240659; 300 for (int i = 0; i < MAC_ADDR_LENGTH; ++i) { 301 lease.chaddr[i] = testMac1[i]; 302 } 303 ASSERT_EQ(RET_SUCCESS, AddLease(&testPool, &lease)); 304 for (int i = 0; i < MAC_ADDR_LENGTH; ++i) { 305 lease.chaddr[i] = testMac2[i]; 306 } 307 EXPECT_EQ(RET_ERROR, AddLease(NULL, &lease)); 308 EXPECT_EQ(RET_ERROR, AddLease(&testPool, NULL)); 309 EXPECT_EQ(RET_SUCCESS, AddLease(&testPool, &lease)); 310 EXPECT_EQ(RET_SUCCESS, RemoveLease(&testPool, &lease)); 311 } 312 313 HWTEST_F(DhcpAddressPoolTest, GetLeaseTest, TestSize.Level1) 314 { 315 AddressBinding lease = {0}; 316 lease.bindingMode = BIND_MODE_DYNAMIC; 317 lease.bindingStatus = BIND_ASSOCIATED; 318 uint8_t testMac1[DHCP_HWADDR_LENGTH] = {0x01, 0x0e, 0x3c, 0x65, 0x3a, 0x09, 0}; 319 uint32_t testIp1 = ParseIpAddr("192.168.100.101"); 320 uint32_t testIp2 = ParseIpAddr("192.168.100.110"); 321 ASSERT_TRUE(testIp1 != 0); 322 ASSERT_TRUE(testIp2 != 0); 323 lease.ipAddress = testIp1; 324 lease.leaseTime = DHCP_LEASE_TIME; 325 lease.pendingTime = 1631240659; 326 lease.bindingTime = 1631240659; 327 for (int i = 0; i < MAC_ADDR_LENGTH; ++i) { 328 lease.chaddr[i] = testMac1[i]; 329 } 330 EXPECT_EQ(RET_SUCCESS, AddLease(&testPool, &lease)); 331 EXPECT_EQ(RET_SUCCESS, AddLease(&testPool, &lease)); 332 EXPECT_EQ(NULL, GetLease(&testPool, 0)); 333 EXPECT_EQ(NULL, GetLease(NULL, testIp1)); 334 EXPECT_EQ(NULL, GetLease(&testPool, testIp2)); 335 AddressBinding *leaseRec = GetLease(&testPool, testIp1); 336 ASSERT_TRUE(leaseRec != NULL); 337 EXPECT_EQ(lease.ipAddress, leaseRec->ipAddress); 338 EXPECT_EQ(lease.leaseTime, leaseRec->leaseTime); 339 EXPECT_EQ(lease.bindingMode, leaseRec->bindingMode); 340 EXPECT_EQ(lease.bindingStatus, leaseRec->bindingStatus); 341 EXPECT_EQ(RET_SUCCESS, RemoveLease(&testPool, &lease)); 342 } 343 344 HWTEST_F(DhcpAddressPoolTest, UpdateLeaseTest, TestSize.Level1) 345 { 346 AddressBinding lease = {0}; 347 lease.bindingMode = BIND_MODE_DYNAMIC; 348 lease.bindingStatus = BIND_ASSOCIATED; 349 uint8_t testMac1[DHCP_HWADDR_LENGTH] = {0x01, 0x0e, 0x3c, 0x65, 0x3a, 0x09, 0}; 350 uint32_t testIp1 = ParseIpAddr("192.168.100.101"); 351 uint32_t testIp2 = ParseIpAddr("192.168.100.110"); 352 ASSERT_TRUE(testIp1 != 0); 353 ASSERT_TRUE(testIp2 != 0); 354 lease.ipAddress = testIp1; 355 lease.leaseTime = DHCP_LEASE_TIME; 356 lease.pendingTime = 1631240659; 357 lease.bindingTime = 1631240659; 358 for (int i = 0; i < MAC_ADDR_LENGTH; ++i) { 359 lease.chaddr[i] = testMac1[i]; 360 } 361 EXPECT_EQ(RET_SUCCESS, AddLease(&testPool, &lease)); 362 AddressBinding *leaseRec = GetLease(&testPool, testIp1); 363 ASSERT_TRUE(leaseRec != NULL); 364 EXPECT_EQ(lease.ipAddress, leaseRec->ipAddress); 365 EXPECT_EQ(lease.leaseTime, leaseRec->leaseTime); 366 EXPECT_EQ(lease.bindingMode, leaseRec->bindingMode); 367 EXPECT_EQ(lease.bindingStatus, leaseRec->bindingStatus); 368 lease.pendingTime = 1631260680; 369 lease.bindingTime = 1631260680; 370 EXPECT_EQ(RET_SUCCESS, UpdateLease(&testPool, &lease)); 371 EXPECT_EQ(lease.leaseTime, leaseRec->leaseTime); 372 EXPECT_EQ(lease.leaseTime, leaseRec->leaseTime); 373 EXPECT_EQ(RET_ERROR, UpdateLease(NULL, &lease)); 374 EXPECT_EQ(RET_ERROR, UpdateLease(&testPool, NULL)); 375 lease.ipAddress = testIp2; 376 EXPECT_EQ(RET_FAILED, UpdateLease(&testPool, &lease)); 377 lease.ipAddress = testIp1; 378 EXPECT_EQ(RET_SUCCESS, RemoveLease(&testPool, &lease)); 379 } 380 381 382 HWTEST_F(DhcpAddressPoolTest, LoadBindingRecodersTest, TestSize.Level1) 383 { 384 AddressBinding lease = {0}; 385 uint32_t testIp1 = ParseIpAddr("192.168.100.101"); 386 ASSERT_TRUE(testIp1 != 0); 387 uint32_t testIp2 = ParseIpAddr("192.168.100.102"); 388 ASSERT_TRUE(testIp2 != 0); 389 uint32_t testIp3 = ParseIpAddr("192.168.100.103"); 390 ASSERT_TRUE(testIp3!= 0); 391 392 lease.bindingMode = BIND_MODE_DYNAMIC; 393 lease.bindingStatus = BIND_ASSOCIATED; 394 lease.pendingTime = 1631260680; 395 lease.bindingTime = 1631260680; 396 397 uint8_t testMac1[DHCP_HWADDR_LENGTH] = {0x01, 0x0e, 0x3c, 0x65, 0x3a, 0x09, 0}; 398 uint8_t testMac2[DHCP_HWADDR_LENGTH] = {0x01, 0x0e, 0x3c, 0x65, 0x3a, 0x0a, 0}; 399 uint8_t testMac3[DHCP_HWADDR_LENGTH] = {0x01, 0x0e, 0x3c, 0x65, 0x3a, 0x0b, 0}; 400 lease.ipAddress = testIp1; 401 for (int i = 0; i < MAC_ADDR_LENGTH; ++i) { 402 lease.chaddr[i] = testMac1[i]; 403 } 404 EXPECT_EQ(RET_SUCCESS, AddLease(&testPool, &lease)); 405 lease.ipAddress = testIp2; 406 for (int i = 0; i < MAC_ADDR_LENGTH; ++i) { 407 lease.chaddr[i] = testMac2[i]; 408 } 409 EXPECT_EQ(RET_SUCCESS, AddLease(&testPool, &lease)); 410 lease.ipAddress = testIp3; 411 for (int i = 0; i < MAC_ADDR_LENGTH; ++i) { 412 lease.chaddr[i] = testMac3[i]; 413 } 414 EXPECT_EQ(RET_SUCCESS, AddLease(&testPool, &lease)); 415 416 EXPECT_EQ(RET_SUCCESS, SaveBindingRecoders(&testPool, 1)); 417 EXPECT_EQ(HASH_SUCCESS, ClearAll(&testPool.leaseTable)); 418 EXPECT_TRUE(testPool.leaseTable.size == 0); 419 EXPECT_EQ(RET_FAILED, LoadBindingRecoders(NULL)); 420 EXPECT_EQ(RET_SUCCESS, LoadBindingRecoders(&testPool)); 421 EXPECT_TRUE(testPool.leaseTable.size == 3); 422 EXPECT_TRUE(GetLease(&testPool, testIp1) != NULL); 423 EXPECT_TRUE(GetLease(&testPool, testIp2) != NULL); 424 EXPECT_TRUE(GetLease(&testPool, testIp3) != NULL); 425 EXPECT_EQ(HASH_SUCCESS, ClearAll(&testPool.leaseTable)); 426 } 427 428 429 extern "C" int CheckRangeAvailability( 430 DhcpAddressPool *pool, uint8_t macAddr[DHCP_HWADDR_LENGTH], uint32_t distIp, int *outOfRange); 431 432 HWTEST_F(DhcpAddressPoolTest, CheckRangeAvailabilityTest, TestSize.Level1) 433 { 434 uint8_t testMac1[DHCP_HWADDR_LENGTH] = {0x01, 0x0e, 0x3c, 0x65, 0x3a, 0x09, 0}; 435 uint8_t testMac2[DHCP_HWADDR_LENGTH] = {0x01, 0x0e, 0x3c, 0x65, 0x3a, 0x0a, 0}; 436 uint8_t testMac3[DHCP_HWADDR_LENGTH] = {0x01, 0x0e, 0x3c, 0x65, 0x3b, 0x0b, 0}; 437 uint8_t testMac4[DHCP_HWADDR_LENGTH] = {0}; 438 439 uint32_t testIp1 = ParseIpAddr("192.168.100.101"); 440 uint32_t testIp2 = ParseIpAddr("192.168.100.102"); 441 uint32_t testIp3 = ParseIpAddr("192.168.100.3"); 442 443 int outOfRange = 0; 444 EXPECT_EQ(RET_ERROR, CheckRangeAvailability(NULL, testMac1, testIp1, &outOfRange)); 445 EXPECT_EQ(RET_ERROR, CheckRangeAvailability(&testPool, testMac1, testIp1, &outOfRange)); 446 EXPECT_TRUE(SamplePoolConfig()); 447 EXPECT_EQ(RET_ERROR, CheckRangeAvailability(&testPool, testMac4, testIp1, &outOfRange)); 448 EXPECT_EQ(0, outOfRange); 449 EXPECT_EQ(RET_SUCCESS, CheckRangeAvailability(&testPool, testMac1, testIp1, &outOfRange)); 450 EXPECT_EQ(0, outOfRange); 451 EXPECT_EQ(RET_SUCCESS, CheckRangeAvailability(&testPool, testMac2, testIp2, &outOfRange)); 452 EXPECT_EQ(0, outOfRange); 453 EXPECT_EQ(RET_FAILED, CheckRangeAvailability(&testPool, testMac3, testIp3, &outOfRange)); 454 EXPECT_EQ(1, outOfRange); 455 456 457 458 } 459 460 extern "C" int CheckIpAvailability(DhcpAddressPool *pool, uint8_t macAddr[DHCP_HWADDR_LENGTH], uint32_t distIp); 461 HWTEST_F(DhcpAddressPoolTest, CheckIpAvailabilityTest, TestSize.Level1) 462 { 463 AddressBinding lease = {0}; 464 lease.bindingMode = BIND_MODE_DYNAMIC; 465 lease.bindingStatus = BIND_ASSOCIATED; 466 uint8_t testMac1[DHCP_HWADDR_LENGTH] = {0x0d, 0x0a, 0x3c, 0x65, 0x3a, 0x09, 0}; 467 uint8_t testMac2[DHCP_HWADDR_LENGTH] = {0x0d, 0x0a, 0x3d, 0x65, 0x3a, 0x0a, 0}; 468 uint8_t testMac3[DHCP_HWADDR_LENGTH] = {0x0d, 0x0a, 0x3d, 0x65, 0x3a, 0x0b, 0}; 469 uint32_t testIp1 = ParseIpAddr("192.168.100.101"); 470 uint32_t testIp2 = ParseIpAddr("192.168.100.102"); 471 uint32_t testIp3 = ParseIpAddr("192.168.150.103"); 472 ASSERT_TRUE(testIp1 != 0); 473 ASSERT_TRUE(testIp2 != 0); 474 ASSERT_TRUE(testIp3 != 0); 475 lease.ipAddress = testIp1; 476 lease.leaseTime = DHCP_LEASE_TIME; 477 lease.pendingTime = 1631240659; 478 lease.bindingTime = 1631240659; 479 for (int i = 0; i < MAC_ADDR_LENGTH; ++i) { 480 lease.chaddr[i] = testMac1[i]; 481 } 482 lease.bindingMode = BIND_MODE_DYNAMIC; 483 lease.bindingStatus = BIND_ASSOCIATED; 484 EXPECT_EQ(RET_SUCCESS, AddBinding(&lease)); 485 ASSERT_EQ(RET_SUCCESS, AddLease(&testPool, &lease)); 486 EXPECT_EQ(DHCP_TRUE, CheckIpAvailability(&testPool, testMac1, testIp1)); 487 AddressBinding *pLease = GetLease(&testPool, testIp1); 488 ASSERT_TRUE(pLease != NULL); 489 pLease->bindingMode = BIND_MODE_STATIC; 490 EXPECT_EQ(DHCP_FALSE, CheckIpAvailability(&testPool, testMac2, testIp1)); 491 pLease->bindingMode = BIND_MODE_DYNAMIC; 492 493 for (int i = 0; i < MAC_ADDR_LENGTH; ++i) { 494 lease.chaddr[i] = testMac2[i]; 495 } 496 lease.ipAddress = testIp2; 497 lease.bindingMode = BIND_MODE_RESERVED; 498 EXPECT_EQ(RET_SUCCESS, AddBinding(&lease)); 499 EXPECT_EQ(RET_SUCCESS, AddLease(&testPool, &lease)); 500 EXPECT_EQ(DHCP_FALSE, CheckIpAvailability(&testPool, testMac2, testIp2)); 501 502 EXPECT_TRUE(SamplePoolConfig()); 503 EXPECT_EQ(DHCP_FALSE, CheckIpAvailability(NULL, testMac1, testIp1)); 504 EXPECT_EQ(DHCP_FALSE, CheckIpAvailability(&testPool, testMac3, testIp1)); 505 506 pLease->pendingTime = Tmspsec() - DHCP_LEASE_TIME - 2600; 507 pLease->bindingTime = pLease->pendingTime; 508 EXPECT_EQ(DHCP_TRUE, CheckIpAvailability(&testPool, testMac3, testIp1)); 509 } 510 511 512 extern "C" AddressBinding *GetBindingByMac(HashTable *bindTable, uint8_t macAddr[DHCP_HWADDR_LENGTH]); 513 514 HWTEST_F(DhcpAddressPoolTest, GetBindingByMacTest, TestSize.Level1) 515 { 516 AddressBinding lease = {0}; 517 uint32_t testIp1 = ParseIpAddr("192.168.100.101"); 518 ASSERT_TRUE(testIp1 != 0); 519 lease.bindingMode = BIND_MODE_DYNAMIC; 520 lease.bindingStatus = BIND_ASSOCIATED; 521 lease.pendingTime = 1631260680; 522 lease.bindingTime = 1631260680; 523 uint8_t testMac1[DHCP_HWADDR_LENGTH] = {0x01, 0x0e, 0x3c, 0x65, 0x3a, 0x09, 0}; 524 lease.ipAddress = testIp1; 525 for (int i = 0; i < MAC_ADDR_LENGTH; ++i) { 526 lease.chaddr[i] = testMac1[i]; 527 } 528 ASSERT_EQ(RET_SUCCESS, AddBinding(&lease)); 529 AddressBinding *binding = QueryBinding(testMac1, 0); 530 ASSERT_TRUE(binding != NULL); 531 HashTable tempTable = {0}; 532 EXPECT_TRUE(GetBindingByMac(NULL, testMac1) == NULL); 533 EXPECT_TRUE(GetBindingByMac(&tempTable, testMac1) == NULL); 534 EXPECT_EQ(lease.ipAddress, binding->ipAddress); 535 EXPECT_EQ(lease.leaseTime, binding->leaseTime); 536 EXPECT_EQ(lease.bindingMode, binding->bindingMode); 537 EXPECT_EQ(lease.bindingStatus, binding->bindingStatus); 538 EXPECT_EQ(RET_SUCCESS, RemoveBinding(testMac1)); 539 } 540 541 HWTEST_F(DhcpAddressPoolTest, GetBindingByIpTest, TestSize.Level1) 542 { 543 AddressBinding lease = {0}; 544 uint32_t testIp1 = ParseIpAddr("192.168.100.101"); 545 ASSERT_TRUE(testIp1 != 0); 546 lease.bindingMode = BIND_MODE_DYNAMIC; 547 lease.bindingStatus = BIND_ASSOCIATED; 548 lease.pendingTime = 1631260680; 549 lease.bindingTime = 1631260680; 550 uint8_t testMac1[DHCP_HWADDR_LENGTH] = {0x01, 0x0e, 0x3c, 0x65, 0x3a, 0x09, 0}; 551 lease.ipAddress = testIp1; 552 for (int i = 0; i < MAC_ADDR_LENGTH; ++i) { 553 lease.chaddr[i] = testMac1[i]; 554 } 555 ASSERT_EQ(RET_SUCCESS, AddLease(&testPool, &lease)); 556 557 HashTable tempTable = {0}; 558 EXPECT_TRUE(GetBindingByIp(NULL, testIp1) == NULL); 559 EXPECT_TRUE(GetBindingByIp(&tempTable, testIp1) == NULL); 560 AddressBinding *pLease = GetLease(&testPool, testIp1); 561 ASSERT_TRUE(pLease != NULL); 562 EXPECT_EQ(lease.ipAddress, pLease->ipAddress); 563 EXPECT_EQ(lease.leaseTime, pLease->leaseTime); 564 EXPECT_EQ(lease.bindingMode, pLease->bindingMode); 565 EXPECT_EQ(lease.bindingStatus, pLease->bindingStatus); 566 } 567 568 HWTEST_F(DhcpAddressPoolTest, InitAddressPoolTest, TestSize.Level1) 569 { 570 DhcpAddressPool tempPool; 571 ASSERT_TRUE(memset_s(&tempPool, sizeof(DhcpAddressPool), 0, sizeof(DhcpAddressPool)) == EOK); 572 tempPool.fixedOptions.size = 100; 573 EXPECT_EQ(RET_ERROR, InitAddressPool(NULL, "test_if2", NULL)); 574 EXPECT_EQ(RET_SUCCESS, InitAddressPool(&tempPool, "test_if2", NULL)); 575 FreeAddressPool(NULL); 576 FreeAddressPool(&tempPool); 577 } 578 579 extern "C" uint32_t NextIpOffset(uint32_t netmask); 580 HWTEST_F(DhcpAddressPoolTest, NextIpOffsetTest, TestSize.Level1) 581 { 582 uint32_t netmask = ParseIpAddr("255.255.255.0"); 583 ASSERT_TRUE(netmask != 0); 584 SetDistributeMode(0); 585 EXPECT_TRUE(NextIpOffset(netmask) == 0); 586 SetDistributeMode(1); 587 usleep(10); 588 uint32_t nextOffset = NextIpOffset(netmask); 589 EXPECT_TRUE(nextOffset >= 0); 590 SetDistributeMode(0); 591 } 592 593 HWTEST_F(DhcpAddressPoolTest, RemoveLeaseFailedTest, TestSize.Level1) 594 { 595 AddressBinding lease = {0}; 596 uint32_t testIp1 = ParseIpAddr("192.168.100.110"); 597 ASSERT_TRUE(testIp1 != 0); 598 uint8_t testMac1[DHCP_HWADDR_LENGTH] = {0x00, 0x0e, 0x3c, 0x65, 0x3a, 0x09, 0}; 599 lease.ipAddress = testIp1; 600 for (int i = 0; i < MAC_ADDR_LENGTH; ++i) { 601 lease.chaddr[i] = testMac1[i]; 602 } 603 EXPECT_EQ(RET_ERROR, RemoveLease(NULL, &lease)); 604 EXPECT_EQ(RET_ERROR, RemoveLease(&testPool, NULL)); 605 EXPECT_EQ(RET_FAILED, RemoveLease(&testPool, &lease)); 606 }