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