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