1 /*- 2 * BSD LICENSE 3 * 4 * Copyright (c) Intel Corporation. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * * Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * * Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * * Neither the name of Intel Corporation nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 #include "spdk/stdinc.h" 34 35 #include "spdk_cunit.h" 36 #include "CUnit/Basic.h" 37 38 #include "iscsi/init_grp.c" 39 #include "unit/lib/json_mock.c" 40 41 SPDK_LOG_REGISTER_COMPONENT(iscsi) 42 43 struct spdk_iscsi_globals g_iscsi; 44 45 static int 46 test_setup(void) 47 { 48 TAILQ_INIT(&g_iscsi.ig_head); 49 return 0; 50 } 51 52 static void 53 create_initiator_group_success_case(void) 54 { 55 struct spdk_iscsi_init_grp *ig; 56 57 ig = iscsi_init_grp_create(1); 58 CU_ASSERT(ig != NULL); 59 60 iscsi_init_grp_destroy(ig); 61 } 62 63 static void 64 find_initiator_group_success_case(void) 65 { 66 struct spdk_iscsi_init_grp *ig, *tmp; 67 int rc; 68 69 ig = iscsi_init_grp_create(1); 70 CU_ASSERT(ig != NULL); 71 72 rc = iscsi_init_grp_register(ig); 73 CU_ASSERT(rc == 0); 74 75 ig = iscsi_init_grp_find_by_tag(1); 76 CU_ASSERT(ig != NULL); 77 78 tmp = iscsi_init_grp_unregister(1); 79 CU_ASSERT(ig == tmp); 80 iscsi_init_grp_destroy(ig); 81 82 ig = iscsi_init_grp_find_by_tag(1); 83 CU_ASSERT(ig == NULL); 84 } 85 86 static void 87 register_initiator_group_twice_case(void) 88 { 89 struct spdk_iscsi_init_grp *ig, *tmp; 90 int rc; 91 92 ig = iscsi_init_grp_create(1); 93 CU_ASSERT(ig != NULL); 94 95 rc = iscsi_init_grp_register(ig); 96 CU_ASSERT(rc == 0); 97 98 rc = iscsi_init_grp_register(ig); 99 CU_ASSERT(rc != 0); 100 101 ig = iscsi_init_grp_find_by_tag(1); 102 CU_ASSERT(ig != NULL); 103 104 tmp = iscsi_init_grp_unregister(1); 105 CU_ASSERT(tmp == ig); 106 iscsi_init_grp_destroy(ig); 107 108 ig = iscsi_init_grp_find_by_tag(1); 109 CU_ASSERT(ig == NULL); 110 } 111 112 static void 113 add_initiator_name_success_case(void) 114 { 115 116 int rc; 117 struct spdk_iscsi_init_grp *ig; 118 struct spdk_iscsi_initiator_name *iname; 119 char *name1 = "iqn.2017-10.spdk.io:0001"; 120 char *name2 = "iqn.2017-10.spdk.io:0002"; 121 122 ig = iscsi_init_grp_create(1); 123 CU_ASSERT(ig != NULL); 124 125 /* add two different names to the empty name list */ 126 rc = iscsi_init_grp_add_initiator(ig, name1); 127 CU_ASSERT(rc == 0); 128 129 rc = iscsi_init_grp_add_initiator(ig, name2); 130 CU_ASSERT(rc == 0); 131 132 /* check if two names are added correctly. */ 133 iname = iscsi_init_grp_find_initiator(ig, name1); 134 CU_ASSERT(iname != NULL); 135 136 iname = iscsi_init_grp_find_initiator(ig, name2); 137 CU_ASSERT(iname != NULL); 138 139 /* restore the initial state */ 140 rc = iscsi_init_grp_delete_initiator(ig, name1); 141 CU_ASSERT(rc == 0); 142 143 iname = iscsi_init_grp_find_initiator(ig, name1); 144 CU_ASSERT(iname == NULL); 145 146 rc = iscsi_init_grp_delete_initiator(ig, name2); 147 CU_ASSERT(rc == 0); 148 149 iname = iscsi_init_grp_find_initiator(ig, name2); 150 CU_ASSERT(iname == NULL); 151 152 iscsi_init_grp_destroy(ig); 153 } 154 155 static void 156 add_initiator_name_fail_case(void) 157 { 158 int rc; 159 struct spdk_iscsi_init_grp *ig; 160 struct spdk_iscsi_initiator_name *iname; 161 char *name1 = "iqn.2017-10.spdk.io:0001"; 162 163 ig = iscsi_init_grp_create(1); 164 CU_ASSERT(ig != NULL); 165 166 /* add an name to the full name list */ 167 ig->ninitiators = MAX_INITIATOR; 168 169 rc = iscsi_init_grp_add_initiator(ig, name1); 170 CU_ASSERT(rc != 0); 171 172 ig->ninitiators = 0; 173 174 /* add the same name to the name list twice */ 175 rc = iscsi_init_grp_add_initiator(ig, name1); 176 CU_ASSERT(rc == 0); 177 178 rc = iscsi_init_grp_add_initiator(ig, name1); 179 CU_ASSERT(rc != 0); 180 181 /* restore the initial state */ 182 rc = iscsi_init_grp_delete_initiator(ig, name1); 183 CU_ASSERT(rc == 0); 184 185 iname = iscsi_init_grp_find_initiator(ig, name1); 186 CU_ASSERT(iname == NULL); 187 188 iscsi_init_grp_destroy(ig); 189 } 190 191 static void 192 delete_all_initiator_names_success_case(void) 193 { 194 int rc; 195 struct spdk_iscsi_init_grp *ig; 196 struct spdk_iscsi_initiator_name *iname; 197 char *name1 = "iqn.2017-10.spdk.io:0001"; 198 char *name2 = "iqn.2017-10.spdk.io:0002"; 199 200 ig = iscsi_init_grp_create(1); 201 CU_ASSERT(ig != NULL); 202 203 /* add two different names to the empty name list */ 204 rc = iscsi_init_grp_add_initiator(ig, name1); 205 CU_ASSERT(rc == 0); 206 207 rc = iscsi_init_grp_add_initiator(ig, name2); 208 CU_ASSERT(rc == 0); 209 210 /* delete all initiator names */ 211 iscsi_init_grp_delete_all_initiators(ig); 212 213 /* check if two names are deleted correctly. */ 214 iname = iscsi_init_grp_find_initiator(ig, name1); 215 CU_ASSERT(iname == NULL); 216 217 iname = iscsi_init_grp_find_initiator(ig, name2); 218 CU_ASSERT(iname == NULL); 219 220 /* restore the initial state */ 221 iscsi_init_grp_destroy(ig); 222 } 223 224 static void 225 add_netmask_success_case(void) 226 { 227 int rc; 228 struct spdk_iscsi_init_grp *ig; 229 struct spdk_iscsi_initiator_netmask *imask; 230 char *netmask1 = "192.168.2.0"; 231 char *netmask2 = "192.168.2.1"; 232 233 ig = iscsi_init_grp_create(1); 234 CU_ASSERT(ig != NULL); 235 236 /* add two different netmasks to the empty netmask list */ 237 rc = iscsi_init_grp_add_netmask(ig, netmask1); 238 CU_ASSERT(rc == 0); 239 240 rc = iscsi_init_grp_add_netmask(ig, netmask2); 241 CU_ASSERT(rc == 0); 242 243 /* check if two netmasks are added correctly. */ 244 imask = iscsi_init_grp_find_netmask(ig, netmask1); 245 CU_ASSERT(imask != NULL); 246 247 imask = iscsi_init_grp_find_netmask(ig, netmask2); 248 CU_ASSERT(imask != NULL); 249 250 /* restore the initial state */ 251 rc = iscsi_init_grp_delete_netmask(ig, netmask1); 252 CU_ASSERT(rc == 0); 253 254 imask = iscsi_init_grp_find_netmask(ig, netmask1); 255 CU_ASSERT(imask == NULL); 256 257 rc = iscsi_init_grp_delete_netmask(ig, netmask2); 258 CU_ASSERT(rc == 0); 259 260 imask = iscsi_init_grp_find_netmask(ig, netmask2); 261 CU_ASSERT(imask == NULL); 262 263 iscsi_init_grp_destroy(ig); 264 } 265 266 static void 267 add_netmask_fail_case(void) 268 { 269 int rc; 270 struct spdk_iscsi_init_grp *ig; 271 struct spdk_iscsi_initiator_netmask *imask; 272 char *netmask1 = "192.168.2.0"; 273 274 ig = iscsi_init_grp_create(1); 275 CU_ASSERT(ig != NULL); 276 277 /* add an netmask to the full netmask list */ 278 ig->nnetmasks = MAX_NETMASK; 279 280 rc = iscsi_init_grp_add_netmask(ig, netmask1); 281 CU_ASSERT(rc != 0); 282 283 ig->nnetmasks = 0; 284 285 /* add the same netmask to the netmask list twice */ 286 rc = iscsi_init_grp_add_netmask(ig, netmask1); 287 CU_ASSERT(rc == 0); 288 289 rc = iscsi_init_grp_add_netmask(ig, netmask1); 290 CU_ASSERT(rc != 0); 291 292 /* restore the initial state */ 293 rc = iscsi_init_grp_delete_netmask(ig, netmask1); 294 CU_ASSERT(rc == 0); 295 296 imask = iscsi_init_grp_find_netmask(ig, netmask1); 297 CU_ASSERT(imask == NULL); 298 299 iscsi_init_grp_destroy(ig); 300 } 301 302 static void 303 delete_all_netmasks_success_case(void) 304 { 305 int rc; 306 struct spdk_iscsi_init_grp *ig; 307 struct spdk_iscsi_initiator_netmask *imask; 308 char *netmask1 = "192.168.2.0"; 309 char *netmask2 = "192.168.2.1"; 310 311 ig = iscsi_init_grp_create(1); 312 CU_ASSERT(ig != NULL); 313 314 /* add two different netmasks to the empty netmask list */ 315 rc = iscsi_init_grp_add_netmask(ig, netmask1); 316 CU_ASSERT(rc == 0); 317 318 rc = iscsi_init_grp_add_netmask(ig, netmask2); 319 CU_ASSERT(rc == 0); 320 321 /* delete all netmasks */ 322 iscsi_init_grp_delete_all_netmasks(ig); 323 324 /* check if two netmasks are deleted correctly. */ 325 imask = iscsi_init_grp_find_netmask(ig, netmask1); 326 CU_ASSERT(imask == NULL); 327 328 imask = iscsi_init_grp_find_netmask(ig, netmask2); 329 CU_ASSERT(imask == NULL); 330 331 /* restore the initial state */ 332 iscsi_init_grp_destroy(ig); 333 } 334 335 static void 336 initiator_name_overwrite_all_to_any_case(void) 337 { 338 int rc; 339 struct spdk_iscsi_init_grp *ig; 340 struct spdk_iscsi_initiator_name *iname; 341 char *all = "ALL"; 342 char *any = "ANY"; 343 char *all_not = "!ALL"; 344 char *any_not = "!ANY"; 345 346 ig = iscsi_init_grp_create(1); 347 CU_ASSERT(ig != NULL); 348 349 rc = iscsi_init_grp_add_initiator(ig, all); 350 CU_ASSERT(rc == 0); 351 352 iname = iscsi_init_grp_find_initiator(ig, all); 353 CU_ASSERT(iname == NULL); 354 355 iname = iscsi_init_grp_find_initiator(ig, any); 356 CU_ASSERT(iname != NULL); 357 358 rc = iscsi_init_grp_delete_initiator(ig, any); 359 CU_ASSERT(rc == 0); 360 361 rc = iscsi_init_grp_add_initiator(ig, all_not); 362 CU_ASSERT(rc == 0); 363 364 iname = iscsi_init_grp_find_initiator(ig, all_not); 365 CU_ASSERT(iname == NULL); 366 367 iname = iscsi_init_grp_find_initiator(ig, any_not); 368 CU_ASSERT(iname != NULL); 369 370 rc = iscsi_init_grp_delete_initiator(ig, any_not); 371 CU_ASSERT(rc == 0); 372 373 iscsi_init_grp_destroy(ig); 374 } 375 376 static void 377 netmask_overwrite_all_to_any_case(void) 378 { 379 int rc; 380 struct spdk_iscsi_init_grp *ig; 381 struct spdk_iscsi_initiator_netmask *imask; 382 char *all = "ALL"; 383 char *any = "ANY"; 384 385 ig = iscsi_init_grp_create(1); 386 CU_ASSERT(ig != NULL); 387 388 rc = iscsi_init_grp_add_netmask(ig, all); 389 CU_ASSERT(rc == 0); 390 391 imask = iscsi_init_grp_find_netmask(ig, all); 392 CU_ASSERT(imask == NULL); 393 394 imask = iscsi_init_grp_find_netmask(ig, any); 395 CU_ASSERT(imask != NULL); 396 397 rc = iscsi_init_grp_delete_netmask(ig, any); 398 CU_ASSERT(rc == 0); 399 400 iscsi_init_grp_destroy(ig); 401 } 402 403 static void 404 add_delete_initiator_names_case(void) 405 { 406 int rc, i; 407 struct spdk_iscsi_init_grp *ig; 408 struct spdk_iscsi_initiator_name *iname; 409 char *names[3] = {"iqn.2018-02.spdk.io:0001", "iqn.2018-02.spdk.io:0002", "iqn.2018-02.spdk.io:0003"}; 410 411 ig = iscsi_init_grp_create(1); 412 SPDK_CU_ASSERT_FATAL(ig != NULL); 413 414 rc = iscsi_init_grp_add_initiators(ig, 3, names); 415 CU_ASSERT(rc == 0); 416 417 for (i = 0; i < 3; i++) { 418 iname = iscsi_init_grp_find_initiator(ig, names[i]); 419 CU_ASSERT(iname != NULL); 420 } 421 422 rc = iscsi_init_grp_delete_initiators(ig, 3, names); 423 CU_ASSERT(rc == 0); 424 425 if (ig != NULL) { 426 CU_ASSERT(TAILQ_EMPTY(&ig->initiator_head)); 427 } 428 429 iscsi_init_grp_destroy(ig); 430 } 431 432 static void 433 add_duplicated_initiator_names_case(void) 434 { 435 int rc; 436 struct spdk_iscsi_init_grp *ig; 437 char *names[3] = {"iqn.2018-02.spdk.io:0001", "iqn.2018-02.spdk.io:0002", "iqn.2018-02.spdk.io:0001"}; 438 439 ig = iscsi_init_grp_create(1); 440 SPDK_CU_ASSERT_FATAL(ig != NULL); 441 442 rc = iscsi_init_grp_add_initiators(ig, 3, names); 443 CU_ASSERT(rc != 0); 444 445 if (ig != NULL) { 446 CU_ASSERT(TAILQ_EMPTY(&ig->initiator_head)); 447 } 448 449 iscsi_init_grp_destroy(ig); 450 } 451 452 static void 453 delete_nonexisting_initiator_names_case(void) 454 { 455 int rc, i; 456 struct spdk_iscsi_init_grp *ig; 457 struct spdk_iscsi_initiator_name *iname; 458 char *names1[3] = {"iqn.2018-02.spdk.io:0001", "iqn.2018-02.spdk.io:0002", "iqn.2018-02.spdk.io:0003"}; 459 char *names2[3] = {"iqn.2018-02.spdk.io:0001", "iqn.2018-02.spdk.io:0002", "iqn.2018-02.spdk.io:0004"}; 460 461 ig = iscsi_init_grp_create(1); 462 SPDK_CU_ASSERT_FATAL(ig != NULL); 463 464 rc = iscsi_init_grp_add_initiators(ig, 3, names1); 465 CU_ASSERT(rc == 0); 466 467 for (i = 0; i < 3; i++) { 468 iname = iscsi_init_grp_find_initiator(ig, names1[i]); 469 CU_ASSERT(iname != NULL); 470 } 471 472 rc = iscsi_init_grp_delete_initiators(ig, 3, names2); 473 CU_ASSERT(rc != 0); 474 475 for (i = 0; i < 3; i++) { 476 iname = iscsi_init_grp_find_initiator(ig, names1[i]); 477 CU_ASSERT(iname != NULL); 478 } 479 480 rc = iscsi_init_grp_delete_initiators(ig, 3, names1); 481 CU_ASSERT(rc == 0); 482 483 if (ig != NULL) { 484 CU_ASSERT(TAILQ_EMPTY(&ig->initiator_head)); 485 } 486 487 iscsi_init_grp_destroy(ig); 488 } 489 490 static void 491 add_delete_netmasks_case(void) 492 { 493 int rc, i; 494 struct spdk_iscsi_init_grp *ig; 495 struct spdk_iscsi_initiator_netmask *netmask; 496 char *netmasks[3] = {"192.168.2.0", "192.168.2.1", "192.168.2.2"}; 497 498 ig = iscsi_init_grp_create(1); 499 SPDK_CU_ASSERT_FATAL(ig != NULL); 500 501 rc = iscsi_init_grp_add_netmasks(ig, 3, netmasks); 502 CU_ASSERT(rc == 0); 503 504 for (i = 0; i < 3; i++) { 505 netmask = iscsi_init_grp_find_netmask(ig, netmasks[i]); 506 CU_ASSERT(netmask != NULL); 507 } 508 509 rc = iscsi_init_grp_delete_netmasks(ig, 3, netmasks); 510 CU_ASSERT(rc == 0); 511 512 if (ig != NULL) { 513 CU_ASSERT(TAILQ_EMPTY(&ig->netmask_head)); 514 } 515 516 iscsi_init_grp_destroy(ig); 517 } 518 519 static void 520 add_duplicated_netmasks_case(void) 521 { 522 int rc; 523 struct spdk_iscsi_init_grp *ig; 524 char *netmasks[3] = {"192.168.2.0", "192.168.2.1", "192.168.2.0"}; 525 526 ig = iscsi_init_grp_create(1); 527 SPDK_CU_ASSERT_FATAL(ig != NULL); 528 529 rc = iscsi_init_grp_add_netmasks(ig, 3, netmasks); 530 CU_ASSERT(rc != 0); 531 532 if (ig != NULL) { 533 CU_ASSERT(TAILQ_EMPTY(&ig->netmask_head)); 534 } 535 536 iscsi_init_grp_destroy(ig); 537 } 538 539 static void 540 delete_nonexisting_netmasks_case(void) 541 { 542 int rc, i; 543 struct spdk_iscsi_init_grp *ig; 544 struct spdk_iscsi_initiator_netmask *netmask; 545 char *netmasks1[3] = {"192.168.2.0", "192.168.2.1", "192.168.2.2"}; 546 char *netmasks2[3] = {"192.168.2.0", "192.168.2.1", "192.168.2.3"}; 547 548 ig = iscsi_init_grp_create(1); 549 SPDK_CU_ASSERT_FATAL(ig != NULL); 550 551 rc = iscsi_init_grp_add_netmasks(ig, 3, netmasks1); 552 CU_ASSERT(rc == 0); 553 554 for (i = 0; i < 3; i++) { 555 netmask = iscsi_init_grp_find_netmask(ig, netmasks1[i]); 556 CU_ASSERT(netmask != NULL); 557 } 558 559 rc = iscsi_init_grp_delete_netmasks(ig, 3, netmasks2); 560 CU_ASSERT(rc != 0); 561 562 for (i = 0; i < 3; i++) { 563 netmask = iscsi_init_grp_find_netmask(ig, netmasks1[i]); 564 CU_ASSERT(netmask != NULL); 565 } 566 567 rc = iscsi_init_grp_delete_netmasks(ig, 3, netmasks1); 568 CU_ASSERT(rc == 0); 569 570 if (ig != NULL) { 571 CU_ASSERT(TAILQ_EMPTY(&ig->netmask_head)); 572 } 573 574 iscsi_init_grp_destroy(ig); 575 } 576 577 578 int 579 main(int argc, char **argv) 580 { 581 CU_pSuite suite = NULL; 582 unsigned int num_failures; 583 584 CU_set_error_action(CUEA_ABORT); 585 CU_initialize_registry(); 586 587 suite = CU_add_suite("init_grp_suite", test_setup, NULL); 588 589 CU_ADD_TEST(suite, create_initiator_group_success_case); 590 CU_ADD_TEST(suite, find_initiator_group_success_case); 591 CU_ADD_TEST(suite, register_initiator_group_twice_case); 592 CU_ADD_TEST(suite, add_initiator_name_success_case); 593 CU_ADD_TEST(suite, add_initiator_name_fail_case); 594 CU_ADD_TEST(suite, delete_all_initiator_names_success_case); 595 CU_ADD_TEST(suite, add_netmask_success_case); 596 CU_ADD_TEST(suite, add_netmask_fail_case); 597 CU_ADD_TEST(suite, delete_all_netmasks_success_case); 598 CU_ADD_TEST(suite, initiator_name_overwrite_all_to_any_case); 599 CU_ADD_TEST(suite, netmask_overwrite_all_to_any_case); 600 CU_ADD_TEST(suite, add_delete_initiator_names_case); 601 CU_ADD_TEST(suite, add_duplicated_initiator_names_case); 602 CU_ADD_TEST(suite, delete_nonexisting_initiator_names_case); 603 CU_ADD_TEST(suite, add_delete_netmasks_case); 604 CU_ADD_TEST(suite, add_duplicated_netmasks_case); 605 CU_ADD_TEST(suite, delete_nonexisting_netmasks_case); 606 607 CU_basic_set_mode(CU_BRM_VERBOSE); 608 CU_basic_run_tests(); 609 num_failures = CU_get_number_of_failures(); 610 CU_cleanup_registry(); 611 return num_failures; 612 } 613