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