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 34 #include "spdk/stdinc.h" 35 36 #include "spdk/scsi.h" 37 38 #include "CUnit/Basic.h" 39 #include "spdk_internal/mock.h" 40 41 #include "../common.c" 42 #include "iscsi/tgt_node.c" 43 #include "scsi/scsi_internal.h" 44 #include "unit/lib/json_mock.c" 45 46 struct spdk_iscsi_globals g_spdk_iscsi; 47 48 const char *config_file; 49 50 DEFINE_STUB(spdk_scsi_dev_get_id, 51 int, 52 (const struct spdk_scsi_dev *dev), 53 0); 54 55 DEFINE_STUB(spdk_scsi_lun_get_bdev_name, 56 const char *, 57 (const struct spdk_scsi_lun *lun), 58 NULL); 59 60 DEFINE_STUB(spdk_scsi_lun_get_id, 61 int, 62 (const struct spdk_scsi_lun *lun), 63 0); 64 65 bool 66 spdk_sock_is_ipv6(struct spdk_sock *sock) 67 { 68 return false; 69 } 70 71 bool 72 spdk_sock_is_ipv4(struct spdk_sock *sock) 73 { 74 return false; 75 } 76 77 struct spdk_iscsi_portal_grp * 78 spdk_iscsi_portal_grp_find_by_tag(int tag) 79 { 80 return NULL; 81 } 82 83 struct spdk_iscsi_init_grp * 84 spdk_iscsi_init_grp_find_by_tag(int tag) 85 { 86 return NULL; 87 } 88 89 struct spdk_scsi_lun * 90 spdk_scsi_dev_get_lun(struct spdk_scsi_dev *dev, int lun_id) 91 { 92 if (lun_id < 0 || lun_id >= SPDK_SCSI_DEV_MAX_LUN) { 93 return NULL; 94 } 95 96 return dev->lun[lun_id]; 97 } 98 99 int 100 spdk_scsi_dev_add_lun(struct spdk_scsi_dev *dev, const char *bdev_name, int lun_id, 101 void (*hotremove_cb)(const struct spdk_scsi_lun *, void *), 102 void *hotremove_ctx) 103 { 104 if (bdev_name == NULL) { 105 return -1; 106 } else { 107 return 0; 108 } 109 } 110 111 static void 112 add_lun_test_cases(void) 113 { 114 struct spdk_iscsi_tgt_node tgtnode; 115 int lun_id = 0; 116 char *bdev_name = NULL; 117 struct spdk_scsi_dev scsi_dev; 118 int rc; 119 120 memset(&tgtnode, 0, sizeof(struct spdk_iscsi_tgt_node)); 121 memset(&scsi_dev, 0, sizeof(struct spdk_scsi_dev)); 122 123 /* case 1 */ 124 tgtnode.num_active_conns = 1; 125 126 rc = spdk_iscsi_tgt_node_add_lun(&tgtnode, bdev_name, lun_id); 127 CU_ASSERT(rc != 0); 128 129 /* case 2 */ 130 tgtnode.num_active_conns = 0; 131 lun_id = -2; 132 133 rc = spdk_iscsi_tgt_node_add_lun(&tgtnode, bdev_name, lun_id); 134 CU_ASSERT(rc != 0); 135 136 /* case 3 */ 137 lun_id = SPDK_SCSI_DEV_MAX_LUN; 138 139 rc = spdk_iscsi_tgt_node_add_lun(&tgtnode, bdev_name, lun_id); 140 CU_ASSERT(rc != 0); 141 142 /* case 4 */ 143 lun_id = -1; 144 tgtnode.dev = NULL; 145 146 rc = spdk_iscsi_tgt_node_add_lun(&tgtnode, bdev_name, lun_id); 147 CU_ASSERT(rc != 0); 148 149 /* case 5 */ 150 tgtnode.dev = &scsi_dev; 151 152 rc = spdk_iscsi_tgt_node_add_lun(&tgtnode, bdev_name, lun_id); 153 CU_ASSERT(rc != 0); 154 155 /* case 6 */ 156 bdev_name = "LUN0"; 157 158 rc = spdk_iscsi_tgt_node_add_lun(&tgtnode, bdev_name, lun_id); 159 CU_ASSERT(rc == 0); 160 } 161 162 static void 163 config_file_fail_cases(void) 164 { 165 struct spdk_conf *config; 166 struct spdk_conf_section *sp; 167 char section_name[64]; 168 int section_index; 169 int rc; 170 171 config = spdk_conf_allocate(); 172 173 rc = spdk_conf_read(config, config_file); 174 CU_ASSERT(rc == 0); 175 176 section_index = 0; 177 while (true) { 178 snprintf(section_name, sizeof(section_name), "Failure%d", section_index); 179 sp = spdk_conf_find_section(config, section_name); 180 if (sp == NULL) { 181 break; 182 } 183 rc = spdk_iscsi_parse_tgt_node(sp); 184 CU_ASSERT(rc < 0); 185 section_index++; 186 } 187 188 spdk_conf_free(config); 189 } 190 191 static void 192 allow_any_allowed(void) 193 { 194 bool result; 195 char *netmask; 196 char *addr1, *addr2; 197 198 netmask = "ANY"; 199 addr1 = "2001:ad6:1234:5678:9abc::"; 200 addr2 = "192.168.2.1"; 201 202 result = spdk_iscsi_netmask_allow_addr(netmask, addr1); 203 CU_ASSERT(result == true); 204 205 result = spdk_iscsi_netmask_allow_addr(netmask, addr2); 206 CU_ASSERT(result == true); 207 } 208 209 static void 210 allow_ipv6_allowed(void) 211 { 212 bool result; 213 char *netmask; 214 char *addr; 215 216 netmask = "[2001:ad6:1234::]/48"; 217 addr = "2001:ad6:1234:5678:9abc::"; 218 219 result = spdk_iscsi_ipv6_netmask_allow_addr(netmask, addr); 220 CU_ASSERT(result == true); 221 222 result = spdk_iscsi_netmask_allow_addr(netmask, addr); 223 CU_ASSERT(result == true); 224 225 /* Netmask prefix bits == 128 (all bits must match) */ 226 netmask = "[2001:ad6:1234:5678:9abc::1]/128"; 227 addr = "2001:ad6:1234:5678:9abc::1"; 228 result = spdk_iscsi_ipv6_netmask_allow_addr(netmask, addr); 229 CU_ASSERT(result == true); 230 } 231 232 static void 233 allow_ipv6_denied(void) 234 { 235 bool result; 236 char *netmask; 237 char *addr; 238 239 netmask = "[2001:ad6:1234::]/56"; 240 addr = "2001:ad6:1234:5678:9abc::"; 241 242 result = spdk_iscsi_ipv6_netmask_allow_addr(netmask, addr); 243 CU_ASSERT(result == false); 244 245 result = spdk_iscsi_netmask_allow_addr(netmask, addr); 246 CU_ASSERT(result == false); 247 248 /* Netmask prefix bits == 128 (all bits must match) */ 249 netmask = "[2001:ad6:1234:5678:9abc::1]/128"; 250 addr = "2001:ad6:1234:5678:9abc::2"; 251 result = spdk_iscsi_ipv6_netmask_allow_addr(netmask, addr); 252 CU_ASSERT(result == false); 253 } 254 255 static void 256 allow_ipv6_invalid(void) 257 { 258 bool result; 259 char *netmask; 260 char *addr; 261 262 /* Netmask prefix bits > 128 */ 263 netmask = "[2001:ad6:1234::]/129"; 264 addr = "2001:ad6:1234:5678:9abc::"; 265 result = spdk_iscsi_ipv6_netmask_allow_addr(netmask, addr); 266 CU_ASSERT(result == false); 267 268 /* Netmask prefix bits == 0 */ 269 netmask = "[2001:ad6:1234::]/0"; 270 addr = "2001:ad6:1234:5678:9abc::"; 271 result = spdk_iscsi_ipv6_netmask_allow_addr(netmask, addr); 272 CU_ASSERT(result == false); 273 274 /* Netmask prefix bits < 0 */ 275 netmask = "[2001:ad6:1234::]/-1"; 276 addr = "2001:ad6:1234:5678:9abc::"; 277 result = spdk_iscsi_ipv6_netmask_allow_addr(netmask, addr); 278 CU_ASSERT(result == false); 279 } 280 281 static void 282 allow_ipv4_allowed(void) 283 { 284 bool result; 285 char *netmask; 286 char *addr; 287 288 netmask = "192.168.2.0/24"; 289 addr = "192.168.2.1"; 290 291 result = spdk_iscsi_ipv4_netmask_allow_addr(netmask, addr); 292 CU_ASSERT(result == true); 293 294 result = spdk_iscsi_netmask_allow_addr(netmask, addr); 295 CU_ASSERT(result == true); 296 297 /* Netmask prefix == 32 (all bits must match) */ 298 netmask = "192.168.2.1/32"; 299 addr = "192.168.2.1"; 300 result = spdk_iscsi_ipv4_netmask_allow_addr(netmask, addr); 301 CU_ASSERT(result == true); 302 } 303 304 static void 305 allow_ipv4_denied(void) 306 { 307 bool result; 308 char *netmask; 309 char *addr; 310 311 netmask = "192.168.2.0"; 312 addr = "192.168.2.1"; 313 314 result = spdk_iscsi_ipv4_netmask_allow_addr(netmask, addr); 315 CU_ASSERT(result == false); 316 317 result = spdk_iscsi_netmask_allow_addr(netmask, addr); 318 CU_ASSERT(result == false); 319 320 /* Netmask prefix == 32 (all bits must match) */ 321 netmask = "192.168.2.1/32"; 322 addr = "192.168.2.2"; 323 result = spdk_iscsi_ipv4_netmask_allow_addr(netmask, addr); 324 CU_ASSERT(result == false); 325 } 326 327 static void 328 allow_ipv4_invalid(void) 329 { 330 bool result; 331 char *netmask; 332 char *addr; 333 334 /* Netmask prefix bits > 32 */ 335 netmask = "192.168.2.0/33"; 336 addr = "192.168.2.1"; 337 result = spdk_iscsi_ipv4_netmask_allow_addr(netmask, addr); 338 CU_ASSERT(result == false); 339 340 /* Netmask prefix bits == 0 */ 341 netmask = "192.168.2.0/0"; 342 addr = "192.168.2.1"; 343 result = spdk_iscsi_ipv4_netmask_allow_addr(netmask, addr); 344 CU_ASSERT(result == false); 345 346 /* Netmask prefix bits < 0 */ 347 netmask = "192.168.2.0/-1"; 348 addr = "192.168.2.1"; 349 result = spdk_iscsi_ipv4_netmask_allow_addr(netmask, addr); 350 CU_ASSERT(result == false); 351 } 352 353 static void 354 node_access_allowed(void) 355 { 356 struct spdk_iscsi_tgt_node tgtnode; 357 struct spdk_iscsi_portal_grp pg; 358 struct spdk_iscsi_init_grp ig; 359 struct spdk_iscsi_conn conn; 360 struct spdk_iscsi_portal portal; 361 struct spdk_iscsi_initiator_name iname; 362 struct spdk_iscsi_initiator_netmask imask; 363 struct spdk_scsi_dev scsi_dev; 364 struct spdk_iscsi_pg_map *pg_map; 365 char *iqn, *addr; 366 bool result; 367 368 /* portal group initialization */ 369 memset(&pg, 0, sizeof(struct spdk_iscsi_portal_grp)); 370 pg.tag = 1; 371 372 /* initiator group initialization */ 373 memset(&ig, 0, sizeof(struct spdk_iscsi_init_grp)); 374 ig.tag = 1; 375 376 ig.ninitiators = 1; 377 iname.name = "iqn.2017-10.spdk.io:0001"; 378 TAILQ_INIT(&ig.initiator_head); 379 TAILQ_INSERT_TAIL(&ig.initiator_head, &iname, tailq); 380 381 ig.nnetmasks = 1; 382 imask.mask = "192.168.2.0/24"; 383 TAILQ_INIT(&ig.netmask_head); 384 TAILQ_INSERT_TAIL(&ig.netmask_head, &imask, tailq); 385 386 /* target initialization */ 387 memset(&tgtnode, 0, sizeof(struct spdk_iscsi_tgt_node)); 388 tgtnode.name = "iqn.2017-10.spdk.io:0001"; 389 TAILQ_INIT(&tgtnode.pg_map_head); 390 391 memset(&scsi_dev, 0, sizeof(struct spdk_scsi_dev)); 392 snprintf(scsi_dev.name, sizeof(scsi_dev.name), "iqn.2017-10.spdk.io:0001"); 393 tgtnode.dev = &scsi_dev; 394 395 pg_map = spdk_iscsi_tgt_node_add_pg_map(&tgtnode, &pg); 396 spdk_iscsi_pg_map_add_ig_map(pg_map, &ig); 397 398 /* portal initialization */ 399 memset(&portal, 0, sizeof(struct spdk_iscsi_portal)); 400 portal.group = &pg; 401 portal.host = "192.168.2.0"; 402 portal.port = "3260"; 403 404 /* input for UT */ 405 memset(&conn, 0, sizeof(struct spdk_iscsi_conn)); 406 conn.portal = &portal; 407 408 iqn = "iqn.2017-10.spdk.io:0001"; 409 addr = "192.168.2.1"; 410 411 result = spdk_iscsi_tgt_node_access(&conn, &tgtnode, iqn, addr); 412 CU_ASSERT(result == true); 413 414 spdk_iscsi_pg_map_delete_ig_map(pg_map, &ig); 415 spdk_iscsi_tgt_node_delete_pg_map(&tgtnode, &pg); 416 } 417 418 static void 419 node_access_denied_by_empty_netmask(void) 420 { 421 struct spdk_iscsi_tgt_node tgtnode; 422 struct spdk_iscsi_portal_grp pg; 423 struct spdk_iscsi_init_grp ig; 424 struct spdk_iscsi_conn conn; 425 struct spdk_iscsi_portal portal; 426 struct spdk_iscsi_initiator_name iname; 427 struct spdk_scsi_dev scsi_dev; 428 struct spdk_iscsi_pg_map *pg_map; 429 char *iqn, *addr; 430 bool result; 431 432 /* portal group initialization */ 433 memset(&pg, 0, sizeof(struct spdk_iscsi_portal_grp)); 434 pg.tag = 1; 435 436 /* initiator group initialization */ 437 memset(&ig, 0, sizeof(struct spdk_iscsi_init_grp)); 438 ig.tag = 1; 439 440 ig.ninitiators = 1; 441 iname.name = "iqn.2017-10.spdk.io:0001"; 442 TAILQ_INIT(&ig.initiator_head); 443 TAILQ_INSERT_TAIL(&ig.initiator_head, &iname, tailq); 444 445 ig.nnetmasks = 0; 446 TAILQ_INIT(&ig.netmask_head); 447 448 /* target initialization */ 449 memset(&tgtnode, 0, sizeof(struct spdk_iscsi_tgt_node)); 450 tgtnode.name = "iqn.2017-10.spdk.io:0001"; 451 TAILQ_INIT(&tgtnode.pg_map_head); 452 453 memset(&scsi_dev, 0, sizeof(struct spdk_scsi_dev)); 454 snprintf(scsi_dev.name, sizeof(scsi_dev.name), "iqn.2017-10.spdk.io:0001"); 455 tgtnode.dev = &scsi_dev; 456 457 pg_map = spdk_iscsi_tgt_node_add_pg_map(&tgtnode, &pg); 458 spdk_iscsi_pg_map_add_ig_map(pg_map, &ig); 459 460 /* portal initialization */ 461 memset(&portal, 0, sizeof(struct spdk_iscsi_portal)); 462 portal.group = &pg; 463 portal.host = "192.168.2.0"; 464 portal.port = "3260"; 465 466 /* input for UT */ 467 memset(&conn, 0, sizeof(struct spdk_iscsi_conn)); 468 conn.portal = &portal; 469 470 iqn = "iqn.2017-10.spdk.io:0001"; 471 addr = "192.168.3.1"; 472 473 result = spdk_iscsi_tgt_node_access(&conn, &tgtnode, iqn, addr); 474 CU_ASSERT(result == false); 475 476 spdk_iscsi_pg_map_delete_ig_map(pg_map, &ig); 477 spdk_iscsi_tgt_node_delete_pg_map(&tgtnode, &pg); 478 } 479 480 #define IQN1 "iqn.2017-11.spdk.io:0001" 481 #define NO_IQN1 "!iqn.2017-11.spdk.io:0001" 482 #define IQN2 "iqn.2017-11.spdk.io:0002" 483 #define IP1 "192.168.2.0" 484 #define IP2 "192.168.2.1" 485 486 static void 487 node_access_multi_initiator_groups_cases(void) 488 { 489 struct spdk_iscsi_tgt_node tgtnode; 490 struct spdk_iscsi_conn conn; 491 struct spdk_iscsi_portal_grp pg; 492 struct spdk_iscsi_portal portal; 493 struct spdk_iscsi_init_grp ig1, ig2; 494 struct spdk_iscsi_initiator_name iname1, iname2; 495 struct spdk_iscsi_initiator_netmask imask1, imask2; 496 struct spdk_scsi_dev scsi_dev; 497 struct spdk_iscsi_pg_map *pg_map; 498 char *iqn, *addr; 499 bool result; 500 501 /* target initialization */ 502 memset(&tgtnode, 0, sizeof(struct spdk_iscsi_tgt_node)); 503 tgtnode.name = IQN1; 504 TAILQ_INIT(&tgtnode.pg_map_head); 505 506 memset(&scsi_dev, 0, sizeof(struct spdk_scsi_dev)); 507 snprintf(scsi_dev.name, sizeof(scsi_dev.name), IQN1); 508 tgtnode.dev = &scsi_dev; 509 510 /* initiator group initialization */ 511 memset(&ig1, 0, sizeof(struct spdk_iscsi_init_grp)); 512 ig1.tag = 1; 513 TAILQ_INIT(&ig1.initiator_head); 514 TAILQ_INIT(&ig1.netmask_head); 515 516 ig1.ninitiators = 1; 517 iname1.name = NULL; 518 TAILQ_INSERT_TAIL(&ig1.initiator_head, &iname1, tailq); 519 520 ig1.nnetmasks = 1; 521 imask1.mask = NULL; 522 TAILQ_INSERT_TAIL(&ig1.netmask_head, &imask1, tailq); 523 524 memset(&ig2, 0, sizeof(struct spdk_iscsi_init_grp)); 525 ig2.tag = 2; 526 TAILQ_INIT(&ig2.initiator_head); 527 TAILQ_INIT(&ig2.netmask_head); 528 529 ig2.ninitiators = 1; 530 iname2.name = NULL; 531 TAILQ_INSERT_TAIL(&ig2.initiator_head, &iname2, tailq); 532 533 ig2.nnetmasks = 1; 534 imask2.mask = NULL; 535 TAILQ_INSERT_TAIL(&ig2.netmask_head, &imask2, tailq); 536 537 /* portal group initialization */ 538 memset(&pg, 0, sizeof(struct spdk_iscsi_portal_grp)); 539 pg.tag = 1; 540 541 pg_map = spdk_iscsi_tgt_node_add_pg_map(&tgtnode, &pg); 542 spdk_iscsi_pg_map_add_ig_map(pg_map, &ig1); 543 spdk_iscsi_pg_map_add_ig_map(pg_map, &ig2); 544 545 /* portal initialization */ 546 memset(&portal, 0, sizeof(struct spdk_iscsi_portal)); 547 portal.group = &pg; 548 portal.host = IP1; 549 portal.port = "3260"; 550 551 /* connection initialization */ 552 memset(&conn, 0, sizeof(struct spdk_iscsi_conn)); 553 conn.portal = &portal; 554 555 iqn = IQN1; 556 addr = IP1; 557 558 /* 559 * case 1: 560 * +-------------------------------------------+---------+ 561 * | IG1 | IG2 | | 562 * +-------------------------------------------+ | 563 * | name | addr | name | addr | result | 564 * +-------------------------------------------+---------+ 565 * +-------------------------------------------+---------+ 566 * | denied | - | - | - | denied | 567 * +-------------------------------------------+---------+ 568 */ 569 iname1.name = NO_IQN1; 570 571 result = spdk_iscsi_tgt_node_access(&conn, &tgtnode, iqn, addr); 572 CU_ASSERT(result == false); 573 574 /* 575 * case 2: 576 * +-------------------------------------------+---------+ 577 * | IG1 | IG2 | | 578 * +-------------------------------------------+ | 579 * | name | addr | name | addr | result | 580 * +-------------------------------------------+---------+ 581 * +-------------------------------------------+---------+ 582 * | allowed | allowed | - | - | allowed | 583 * +-------------------------------------------+---------+ 584 */ 585 iname1.name = IQN1; 586 imask1.mask = IP1; 587 588 result = spdk_iscsi_tgt_node_access(&conn, &tgtnode, iqn, addr); 589 CU_ASSERT(result == true); 590 591 /* 592 * case 3: 593 * +-------------------------------------------+---------+ 594 * | IG1 | IG2 | | 595 * +-------------------------------------------+ | 596 * | name | addr | name | addr | result | 597 * +-------------------------------------------+---------+ 598 * +-------------------------------------------+---------+ 599 * | allowed | denied | denied | - | denied | 600 * +-------------------------------------------+---------+ 601 */ 602 iname1.name = IQN1; 603 imask1.mask = IP2; 604 iname2.name = NO_IQN1; 605 606 result = spdk_iscsi_tgt_node_access(&conn, &tgtnode, iqn, addr); 607 CU_ASSERT(result == false); 608 609 /* 610 * case 4: 611 * +-------------------------------------------+---------+ 612 * | IG1 | IG2 | | 613 * +-------------------------------------------+ | 614 * | name | addr | name | addr | result | 615 * +-------------------------------------------+---------+ 616 * +-------------------------------------------+---------+ 617 * | allowed | denied | allowed | allowed | allowed | 618 * +-------------------------------------------+---------+ 619 */ 620 iname1.name = IQN1; 621 imask1.mask = IP2; 622 iname2.name = IQN1; 623 imask2.mask = IP1; 624 625 result = spdk_iscsi_tgt_node_access(&conn, &tgtnode, iqn, addr); 626 CU_ASSERT(result == true); 627 628 /* 629 * case 5: 630 * +---------------------------------------------+---------+ 631 * | IG1 | IG2 | | 632 * +---------------------------------------------+ | 633 * | name | addr | name | addr | result | 634 * +---------------------------------------------+---------+ 635 * +---------------------------------------------+---------+ 636 * | allowed | denied | allowed | denied | denied | 637 * +---------------------------------------------+---------+ 638 */ 639 iname1.name = IQN1; 640 imask1.mask = IP2; 641 iname2.name = IQN1; 642 imask2.mask = IP2; 643 644 result = spdk_iscsi_tgt_node_access(&conn, &tgtnode, iqn, addr); 645 CU_ASSERT(result == false); 646 647 /* 648 * case 6: 649 * +---------------------------------------------+---------+ 650 * | IG1 | IG2 | | 651 * +---------------------------------------------+ | 652 * | name | addr | name | addr | result | 653 * +---------------------------------------------+---------+ 654 * +---------------------------------------------+---------+ 655 * | allowed | denied | not found | - | denied | 656 * +---------------------------------------------+---------+ 657 */ 658 iname1.name = IQN1; 659 imask1.mask = IP2; 660 iname2.name = IQN2; 661 662 result = spdk_iscsi_tgt_node_access(&conn, &tgtnode, iqn, addr); 663 CU_ASSERT(result == false); 664 665 /* 666 * case 7: 667 * +---------------------------------------------+---------+ 668 * | IG1 | IG2 | | 669 * +---------------------------------------------+ | 670 * | name | addr | name | addr | result | 671 * +---------------------------------------------+---------+ 672 * +---------------------------------------------+---------+ 673 * | not found | - | denied | - | denied | 674 * +---------------------------------------------+---------+ 675 */ 676 iname1.name = IQN2; 677 iname2.name = NO_IQN1; 678 679 result = spdk_iscsi_tgt_node_access(&conn, &tgtnode, iqn, addr); 680 CU_ASSERT(result == false); 681 682 /* 683 * case 8: 684 * +---------------------------------------------+---------+ 685 * | IG1 | IG2 | | 686 * +---------------------------------------------+ | 687 * | name | addr | name | addr | result | 688 * +---------------------------------------------+---------+ 689 * +---------------------------------------------+---------+ 690 * | not found | - | allowed | allowed | allowed | 691 * +---------------------------------------------+---------+ 692 */ 693 iname1.name = IQN2; 694 iname2.name = IQN1; 695 imask2.mask = IP1; 696 697 result = spdk_iscsi_tgt_node_access(&conn, &tgtnode, iqn, addr); 698 CU_ASSERT(result == true); 699 700 /* 701 * case 9: 702 * +---------------------------------------------+---------+ 703 * | IG1 | IG2 | | 704 * +---------------------------------------------+ | 705 * | name | addr | name | addr | result | 706 * +---------------------------------------------+---------+ 707 * +---------------------------------------------+---------+ 708 * | not found | - | allowed | denied | denied | 709 * +---------------------------------------------+---------+ 710 */ 711 iname1.name = IQN2; 712 iname2.name = IQN1; 713 imask2.mask = IP2; 714 715 result = spdk_iscsi_tgt_node_access(&conn, &tgtnode, iqn, addr); 716 CU_ASSERT(result == false); 717 718 /* 719 * case 10: 720 * +---------------------------------------------+---------+ 721 * | IG1 | IG2 | | 722 * +---------------------------------------------+ | 723 * | name | addr | name | addr | result | 724 * +---------------------------------------------+---------+ 725 * +---------------------------------------------+---------+ 726 * | not found | - | not found | - | denied | 727 * +---------------------------------------------+---------+ 728 */ 729 iname1.name = IQN2; 730 iname2.name = IQN2; 731 732 result = spdk_iscsi_tgt_node_access(&conn, &tgtnode, iqn, addr); 733 CU_ASSERT(result == false); 734 735 spdk_iscsi_pg_map_delete_ig_map(pg_map, &ig1); 736 spdk_iscsi_pg_map_delete_ig_map(pg_map, &ig2); 737 spdk_iscsi_tgt_node_delete_pg_map(&tgtnode, &pg); 738 } 739 740 static void 741 allow_iscsi_name_multi_maps_case(void) 742 { 743 struct spdk_iscsi_tgt_node tgtnode; 744 struct spdk_iscsi_portal_grp pg1, pg2; 745 struct spdk_iscsi_init_grp ig; 746 struct spdk_iscsi_initiator_name iname; 747 struct spdk_iscsi_pg_map *pg_map1, *pg_map2; 748 struct spdk_scsi_dev scsi_dev; 749 char *iqn; 750 bool result; 751 752 /* target initialization */ 753 memset(&tgtnode, 0, sizeof(struct spdk_iscsi_tgt_node)); 754 TAILQ_INIT(&tgtnode.pg_map_head); 755 756 memset(&scsi_dev, 0, sizeof(struct spdk_scsi_dev)); 757 snprintf(scsi_dev.name, sizeof(scsi_dev.name), IQN1); 758 tgtnode.dev = &scsi_dev; 759 760 /* initiator group initialization */ 761 memset(&ig, 0, sizeof(struct spdk_iscsi_init_grp)); 762 TAILQ_INIT(&ig.initiator_head); 763 764 ig.ninitiators = 1; 765 iname.name = NULL; 766 TAILQ_INSERT_TAIL(&ig.initiator_head, &iname, tailq); 767 768 /* portal group initialization */ 769 memset(&pg1, 0, sizeof(struct spdk_iscsi_portal_grp)); 770 pg1.tag = 1; 771 memset(&pg2, 0, sizeof(struct spdk_iscsi_portal_grp)); 772 pg2.tag = 1; 773 774 pg_map1 = spdk_iscsi_tgt_node_add_pg_map(&tgtnode, &pg1); 775 pg_map2 = spdk_iscsi_tgt_node_add_pg_map(&tgtnode, &pg2); 776 spdk_iscsi_pg_map_add_ig_map(pg_map1, &ig); 777 spdk_iscsi_pg_map_add_ig_map(pg_map2, &ig); 778 779 /* test for IG1 <-> PG1, PG2 case */ 780 iqn = IQN1; 781 782 iname.name = IQN1; 783 784 result = spdk_iscsi_tgt_node_allow_iscsi_name(&tgtnode, iqn); 785 CU_ASSERT(result == true); 786 787 iname.name = IQN2; 788 789 result = spdk_iscsi_tgt_node_allow_iscsi_name(&tgtnode, iqn); 790 CU_ASSERT(result == false); 791 792 spdk_iscsi_pg_map_delete_ig_map(pg_map1, &ig); 793 spdk_iscsi_pg_map_delete_ig_map(pg_map2, &ig); 794 spdk_iscsi_tgt_node_delete_pg_map(&tgtnode, &pg1); 795 spdk_iscsi_tgt_node_delete_pg_map(&tgtnode, &pg2); 796 } 797 798 /* 799 * static bool 800 * spdk_iscsi_check_chap_params(bool disable_chap, bool require_chap, 801 * bool mutual_chap, int chap_group); 802 */ 803 static void 804 chap_param_test_cases(void) 805 { 806 /* Auto */ 807 CU_ASSERT(spdk_iscsi_check_chap_params(false, false, false, 0) == true); 808 809 /* None */ 810 CU_ASSERT(spdk_iscsi_check_chap_params(true, false, false, 0) == true); 811 812 /* CHAP */ 813 CU_ASSERT(spdk_iscsi_check_chap_params(false, true, false, 0) == true); 814 815 /* CHAP Mutual */ 816 CU_ASSERT(spdk_iscsi_check_chap_params(false, true, true, 0) == true); 817 818 /* Check mutual exclusiveness of disabled and required */ 819 CU_ASSERT(spdk_iscsi_check_chap_params(true, true, false, 0) == false); 820 821 /* Mutual requires Required */ 822 CU_ASSERT(spdk_iscsi_check_chap_params(false, false, true, 0) == false); 823 824 /* Remaining combinations */ 825 CU_ASSERT(spdk_iscsi_check_chap_params(true, false, true, 0) == false); 826 CU_ASSERT(spdk_iscsi_check_chap_params(true, true, true, 0) == false); 827 828 /* Valid auth group ID */ 829 CU_ASSERT(spdk_iscsi_check_chap_params(false, false, false, 1) == true); 830 831 /* Invalid auth group ID */ 832 CU_ASSERT(spdk_iscsi_check_chap_params(false, false, false, -1) == false); 833 } 834 835 int 836 main(int argc, char **argv) 837 { 838 CU_pSuite suite = NULL; 839 unsigned int num_failures; 840 841 if (argc < 2) { 842 fprintf(stderr, "usage: %s <config file>\n", argv[0]); 843 exit(1); 844 } 845 846 if (CU_initialize_registry() != CUE_SUCCESS) { 847 return CU_get_error(); 848 } 849 850 config_file = argv[1]; 851 852 suite = CU_add_suite("iscsi_target_node_suite", NULL, NULL); 853 if (suite == NULL) { 854 CU_cleanup_registry(); 855 return CU_get_error(); 856 } 857 858 if ( 859 CU_add_test(suite, "add lun test cases", add_lun_test_cases) == NULL 860 || CU_add_test(suite, "config file fail cases", config_file_fail_cases) == NULL 861 || CU_add_test(suite, "allow any allowed case", allow_any_allowed) == NULL 862 || CU_add_test(suite, "allow ipv6 allowed case", allow_ipv6_allowed) == NULL 863 || CU_add_test(suite, "allow ipv6 denied case", allow_ipv6_denied) == NULL 864 || CU_add_test(suite, "allow ipv6 invalid case", allow_ipv6_invalid) == NULL 865 || CU_add_test(suite, "allow ipv4 allowed case", allow_ipv4_allowed) == NULL 866 || CU_add_test(suite, "allow ipv4 denied case", allow_ipv4_denied) == NULL 867 || CU_add_test(suite, "allow ipv4 invalid case", allow_ipv4_invalid) == NULL 868 || CU_add_test(suite, "node access allowed case", node_access_allowed) == NULL 869 || CU_add_test(suite, "node access denied case (empty netmask)", 870 node_access_denied_by_empty_netmask) == NULL 871 || CU_add_test(suite, "node access multiple initiator groups cases", 872 node_access_multi_initiator_groups_cases) == NULL 873 || CU_add_test(suite, "allow iscsi name case", 874 allow_iscsi_name_multi_maps_case) == NULL 875 || CU_add_test(suite, "chap param test cases", chap_param_test_cases) == NULL 876 ) { 877 CU_cleanup_registry(); 878 return CU_get_error(); 879 } 880 881 CU_basic_set_mode(CU_BRM_VERBOSE); 882 CU_basic_run_tests(); 883 num_failures = CU_get_number_of_failures(); 884 CU_cleanup_registry(); 885 return num_failures; 886 } 887