ctld.c revision 288760
1/*- 2 * Copyright (c) 2012 The FreeBSD Foundation 3 * All rights reserved. 4 * 5 * This software was developed by Edward Tomasz Napierala under sponsorship 6 * from the FreeBSD Foundation. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 * 29 */ 30 31#include <sys/cdefs.h> 32__FBSDID("$FreeBSD: stable/10/usr.sbin/ctld/ctld.c 288760 2015-10-05 09:22:31Z mav $"); 33 34#include <sys/types.h> 35#include <sys/time.h> 36#include <sys/socket.h> 37#include <sys/wait.h> 38#include <netinet/in.h> 39#include <arpa/inet.h> 40#include <assert.h> 41#include <ctype.h> 42#include <errno.h> 43#include <netdb.h> 44#include <signal.h> 45#include <stdbool.h> 46#include <stdio.h> 47#include <stdint.h> 48#include <stdlib.h> 49#include <string.h> 50#include <unistd.h> 51 52#include "ctld.h" 53#include "isns.h" 54 55bool proxy_mode = false; 56 57static volatile bool sighup_received = false; 58static volatile bool sigterm_received = false; 59static volatile bool sigalrm_received = false; 60 61static int nchildren = 0; 62static uint16_t last_portal_group_tag = 0xff; 63 64static void 65usage(void) 66{ 67 68 fprintf(stderr, "usage: ctld [-d][-f config-file]\n"); 69 exit(1); 70} 71 72char * 73checked_strdup(const char *s) 74{ 75 char *c; 76 77 c = strdup(s); 78 if (c == NULL) 79 log_err(1, "strdup"); 80 return (c); 81} 82 83struct conf * 84conf_new(void) 85{ 86 struct conf *conf; 87 88 conf = calloc(1, sizeof(*conf)); 89 if (conf == NULL) 90 log_err(1, "calloc"); 91 TAILQ_INIT(&conf->conf_luns); 92 TAILQ_INIT(&conf->conf_targets); 93 TAILQ_INIT(&conf->conf_auth_groups); 94 TAILQ_INIT(&conf->conf_ports); 95 TAILQ_INIT(&conf->conf_portal_groups); 96 TAILQ_INIT(&conf->conf_pports); 97 TAILQ_INIT(&conf->conf_isns); 98 99 conf->conf_isns_period = 900; 100 conf->conf_isns_timeout = 5; 101 conf->conf_debug = 0; 102 conf->conf_timeout = 60; 103 conf->conf_maxproc = 30; 104 105 return (conf); 106} 107 108void 109conf_delete(struct conf *conf) 110{ 111 struct lun *lun, *ltmp; 112 struct target *targ, *tmp; 113 struct auth_group *ag, *cagtmp; 114 struct portal_group *pg, *cpgtmp; 115 struct pport *pp, *pptmp; 116 struct isns *is, *istmp; 117 118 assert(conf->conf_pidfh == NULL); 119 120 TAILQ_FOREACH_SAFE(lun, &conf->conf_luns, l_next, ltmp) 121 lun_delete(lun); 122 TAILQ_FOREACH_SAFE(targ, &conf->conf_targets, t_next, tmp) 123 target_delete(targ); 124 TAILQ_FOREACH_SAFE(ag, &conf->conf_auth_groups, ag_next, cagtmp) 125 auth_group_delete(ag); 126 TAILQ_FOREACH_SAFE(pg, &conf->conf_portal_groups, pg_next, cpgtmp) 127 portal_group_delete(pg); 128 TAILQ_FOREACH_SAFE(pp, &conf->conf_pports, pp_next, pptmp) 129 pport_delete(pp); 130 TAILQ_FOREACH_SAFE(is, &conf->conf_isns, i_next, istmp) 131 isns_delete(is); 132 assert(TAILQ_EMPTY(&conf->conf_ports)); 133 free(conf->conf_pidfile_path); 134 free(conf); 135} 136 137static struct auth * 138auth_new(struct auth_group *ag) 139{ 140 struct auth *auth; 141 142 auth = calloc(1, sizeof(*auth)); 143 if (auth == NULL) 144 log_err(1, "calloc"); 145 auth->a_auth_group = ag; 146 TAILQ_INSERT_TAIL(&ag->ag_auths, auth, a_next); 147 return (auth); 148} 149 150static void 151auth_delete(struct auth *auth) 152{ 153 TAILQ_REMOVE(&auth->a_auth_group->ag_auths, auth, a_next); 154 155 free(auth->a_user); 156 free(auth->a_secret); 157 free(auth->a_mutual_user); 158 free(auth->a_mutual_secret); 159 free(auth); 160} 161 162const struct auth * 163auth_find(const struct auth_group *ag, const char *user) 164{ 165 const struct auth *auth; 166 167 TAILQ_FOREACH(auth, &ag->ag_auths, a_next) { 168 if (strcmp(auth->a_user, user) == 0) 169 return (auth); 170 } 171 172 return (NULL); 173} 174 175static void 176auth_check_secret_length(struct auth *auth) 177{ 178 size_t len; 179 180 len = strlen(auth->a_secret); 181 if (len > 16) { 182 if (auth->a_auth_group->ag_name != NULL) 183 log_warnx("secret for user \"%s\", auth-group \"%s\", " 184 "is too long; it should be at most 16 characters " 185 "long", auth->a_user, auth->a_auth_group->ag_name); 186 else 187 log_warnx("secret for user \"%s\", target \"%s\", " 188 "is too long; it should be at most 16 characters " 189 "long", auth->a_user, 190 auth->a_auth_group->ag_target->t_name); 191 } 192 if (len < 12) { 193 if (auth->a_auth_group->ag_name != NULL) 194 log_warnx("secret for user \"%s\", auth-group \"%s\", " 195 "is too short; it should be at least 12 characters " 196 "long", auth->a_user, 197 auth->a_auth_group->ag_name); 198 else 199 log_warnx("secret for user \"%s\", target \"%s\", " 200 "is too short; it should be at least 16 characters " 201 "long", auth->a_user, 202 auth->a_auth_group->ag_target->t_name); 203 } 204 205 if (auth->a_mutual_secret != NULL) { 206 len = strlen(auth->a_mutual_secret); 207 if (len > 16) { 208 if (auth->a_auth_group->ag_name != NULL) 209 log_warnx("mutual secret for user \"%s\", " 210 "auth-group \"%s\", is too long; it should " 211 "be at most 16 characters long", 212 auth->a_user, auth->a_auth_group->ag_name); 213 else 214 log_warnx("mutual secret for user \"%s\", " 215 "target \"%s\", is too long; it should " 216 "be at most 16 characters long", 217 auth->a_user, 218 auth->a_auth_group->ag_target->t_name); 219 } 220 if (len < 12) { 221 if (auth->a_auth_group->ag_name != NULL) 222 log_warnx("mutual secret for user \"%s\", " 223 "auth-group \"%s\", is too short; it " 224 "should be at least 12 characters long", 225 auth->a_user, auth->a_auth_group->ag_name); 226 else 227 log_warnx("mutual secret for user \"%s\", " 228 "target \"%s\", is too short; it should be " 229 "at least 16 characters long", 230 auth->a_user, 231 auth->a_auth_group->ag_target->t_name); 232 } 233 } 234} 235 236const struct auth * 237auth_new_chap(struct auth_group *ag, const char *user, 238 const char *secret) 239{ 240 struct auth *auth; 241 242 if (ag->ag_type == AG_TYPE_UNKNOWN) 243 ag->ag_type = AG_TYPE_CHAP; 244 if (ag->ag_type != AG_TYPE_CHAP) { 245 if (ag->ag_name != NULL) 246 log_warnx("cannot mix \"chap\" authentication with " 247 "other types for auth-group \"%s\"", ag->ag_name); 248 else 249 log_warnx("cannot mix \"chap\" authentication with " 250 "other types for target \"%s\"", 251 ag->ag_target->t_name); 252 return (NULL); 253 } 254 255 auth = auth_new(ag); 256 auth->a_user = checked_strdup(user); 257 auth->a_secret = checked_strdup(secret); 258 259 auth_check_secret_length(auth); 260 261 return (auth); 262} 263 264const struct auth * 265auth_new_chap_mutual(struct auth_group *ag, const char *user, 266 const char *secret, const char *user2, const char *secret2) 267{ 268 struct auth *auth; 269 270 if (ag->ag_type == AG_TYPE_UNKNOWN) 271 ag->ag_type = AG_TYPE_CHAP_MUTUAL; 272 if (ag->ag_type != AG_TYPE_CHAP_MUTUAL) { 273 if (ag->ag_name != NULL) 274 log_warnx("cannot mix \"chap-mutual\" authentication " 275 "with other types for auth-group \"%s\"", 276 ag->ag_name); 277 else 278 log_warnx("cannot mix \"chap-mutual\" authentication " 279 "with other types for target \"%s\"", 280 ag->ag_target->t_name); 281 return (NULL); 282 } 283 284 auth = auth_new(ag); 285 auth->a_user = checked_strdup(user); 286 auth->a_secret = checked_strdup(secret); 287 auth->a_mutual_user = checked_strdup(user2); 288 auth->a_mutual_secret = checked_strdup(secret2); 289 290 auth_check_secret_length(auth); 291 292 return (auth); 293} 294 295const struct auth_name * 296auth_name_new(struct auth_group *ag, const char *name) 297{ 298 struct auth_name *an; 299 300 an = calloc(1, sizeof(*an)); 301 if (an == NULL) 302 log_err(1, "calloc"); 303 an->an_auth_group = ag; 304 an->an_initator_name = checked_strdup(name); 305 TAILQ_INSERT_TAIL(&ag->ag_names, an, an_next); 306 return (an); 307} 308 309static void 310auth_name_delete(struct auth_name *an) 311{ 312 TAILQ_REMOVE(&an->an_auth_group->ag_names, an, an_next); 313 314 free(an->an_initator_name); 315 free(an); 316} 317 318bool 319auth_name_defined(const struct auth_group *ag) 320{ 321 if (TAILQ_EMPTY(&ag->ag_names)) 322 return (false); 323 return (true); 324} 325 326const struct auth_name * 327auth_name_find(const struct auth_group *ag, const char *name) 328{ 329 const struct auth_name *auth_name; 330 331 TAILQ_FOREACH(auth_name, &ag->ag_names, an_next) { 332 if (strcmp(auth_name->an_initator_name, name) == 0) 333 return (auth_name); 334 } 335 336 return (NULL); 337} 338 339int 340auth_name_check(const struct auth_group *ag, const char *initiator_name) 341{ 342 if (!auth_name_defined(ag)) 343 return (0); 344 345 if (auth_name_find(ag, initiator_name) == NULL) 346 return (1); 347 348 return (0); 349} 350 351const struct auth_portal * 352auth_portal_new(struct auth_group *ag, const char *portal) 353{ 354 struct auth_portal *ap; 355 char *net, *mask, *str, *tmp; 356 int len, dm, m; 357 358 ap = calloc(1, sizeof(*ap)); 359 if (ap == NULL) 360 log_err(1, "calloc"); 361 ap->ap_auth_group = ag; 362 ap->ap_initator_portal = checked_strdup(portal); 363 mask = str = checked_strdup(portal); 364 net = strsep(&mask, "/"); 365 if (net[0] == '[') 366 net++; 367 len = strlen(net); 368 if (len == 0) 369 goto error; 370 if (net[len - 1] == ']') 371 net[len - 1] = 0; 372 if (strchr(net, ':') != NULL) { 373 struct sockaddr_in6 *sin6 = 374 (struct sockaddr_in6 *)&ap->ap_sa; 375 376 sin6->sin6_len = sizeof(*sin6); 377 sin6->sin6_family = AF_INET6; 378 if (inet_pton(AF_INET6, net, &sin6->sin6_addr) <= 0) 379 goto error; 380 dm = 128; 381 } else { 382 struct sockaddr_in *sin = 383 (struct sockaddr_in *)&ap->ap_sa; 384 385 sin->sin_len = sizeof(*sin); 386 sin->sin_family = AF_INET; 387 if (inet_pton(AF_INET, net, &sin->sin_addr) <= 0) 388 goto error; 389 dm = 32; 390 } 391 if (mask != NULL) { 392 m = strtol(mask, &tmp, 0); 393 if (m < 0 || m > dm || tmp[0] != 0) 394 goto error; 395 } else 396 m = dm; 397 ap->ap_mask = m; 398 free(str); 399 TAILQ_INSERT_TAIL(&ag->ag_portals, ap, ap_next); 400 return (ap); 401 402error: 403 free(ap); 404 log_errx(1, "Incorrect initiator portal '%s'", portal); 405 return (NULL); 406} 407 408static void 409auth_portal_delete(struct auth_portal *ap) 410{ 411 TAILQ_REMOVE(&ap->ap_auth_group->ag_portals, ap, ap_next); 412 413 free(ap->ap_initator_portal); 414 free(ap); 415} 416 417bool 418auth_portal_defined(const struct auth_group *ag) 419{ 420 if (TAILQ_EMPTY(&ag->ag_portals)) 421 return (false); 422 return (true); 423} 424 425const struct auth_portal * 426auth_portal_find(const struct auth_group *ag, const struct sockaddr_storage *ss) 427{ 428 const struct auth_portal *ap; 429 const uint8_t *a, *b; 430 int i; 431 uint8_t bmask; 432 433 TAILQ_FOREACH(ap, &ag->ag_portals, ap_next) { 434 if (ap->ap_sa.ss_family != ss->ss_family) 435 continue; 436 if (ss->ss_family == AF_INET) { 437 a = (const uint8_t *) 438 &((const struct sockaddr_in *)ss)->sin_addr; 439 b = (const uint8_t *) 440 &((const struct sockaddr_in *)&ap->ap_sa)->sin_addr; 441 } else { 442 a = (const uint8_t *) 443 &((const struct sockaddr_in6 *)ss)->sin6_addr; 444 b = (const uint8_t *) 445 &((const struct sockaddr_in6 *)&ap->ap_sa)->sin6_addr; 446 } 447 for (i = 0; i < ap->ap_mask / 8; i++) { 448 if (a[i] != b[i]) 449 goto next; 450 } 451 if (ap->ap_mask % 8) { 452 bmask = 0xff << (8 - (ap->ap_mask % 8)); 453 if ((a[i] & bmask) != (b[i] & bmask)) 454 goto next; 455 } 456 return (ap); 457next: 458 ; 459 } 460 461 return (NULL); 462} 463 464int 465auth_portal_check(const struct auth_group *ag, const struct sockaddr_storage *sa) 466{ 467 468 if (!auth_portal_defined(ag)) 469 return (0); 470 471 if (auth_portal_find(ag, sa) == NULL) 472 return (1); 473 474 return (0); 475} 476 477struct auth_group * 478auth_group_new(struct conf *conf, const char *name) 479{ 480 struct auth_group *ag; 481 482 if (name != NULL) { 483 ag = auth_group_find(conf, name); 484 if (ag != NULL) { 485 log_warnx("duplicated auth-group \"%s\"", name); 486 return (NULL); 487 } 488 } 489 490 ag = calloc(1, sizeof(*ag)); 491 if (ag == NULL) 492 log_err(1, "calloc"); 493 if (name != NULL) 494 ag->ag_name = checked_strdup(name); 495 TAILQ_INIT(&ag->ag_auths); 496 TAILQ_INIT(&ag->ag_names); 497 TAILQ_INIT(&ag->ag_portals); 498 ag->ag_conf = conf; 499 TAILQ_INSERT_TAIL(&conf->conf_auth_groups, ag, ag_next); 500 501 return (ag); 502} 503 504void 505auth_group_delete(struct auth_group *ag) 506{ 507 struct auth *auth, *auth_tmp; 508 struct auth_name *auth_name, *auth_name_tmp; 509 struct auth_portal *auth_portal, *auth_portal_tmp; 510 511 TAILQ_REMOVE(&ag->ag_conf->conf_auth_groups, ag, ag_next); 512 513 TAILQ_FOREACH_SAFE(auth, &ag->ag_auths, a_next, auth_tmp) 514 auth_delete(auth); 515 TAILQ_FOREACH_SAFE(auth_name, &ag->ag_names, an_next, auth_name_tmp) 516 auth_name_delete(auth_name); 517 TAILQ_FOREACH_SAFE(auth_portal, &ag->ag_portals, ap_next, 518 auth_portal_tmp) 519 auth_portal_delete(auth_portal); 520 free(ag->ag_name); 521 free(ag); 522} 523 524struct auth_group * 525auth_group_find(const struct conf *conf, const char *name) 526{ 527 struct auth_group *ag; 528 529 TAILQ_FOREACH(ag, &conf->conf_auth_groups, ag_next) { 530 if (ag->ag_name != NULL && strcmp(ag->ag_name, name) == 0) 531 return (ag); 532 } 533 534 return (NULL); 535} 536 537int 538auth_group_set_type(struct auth_group *ag, const char *str) 539{ 540 int type; 541 542 if (strcmp(str, "none") == 0) { 543 type = AG_TYPE_NO_AUTHENTICATION; 544 } else if (strcmp(str, "deny") == 0) { 545 type = AG_TYPE_DENY; 546 } else if (strcmp(str, "chap") == 0) { 547 type = AG_TYPE_CHAP; 548 } else if (strcmp(str, "chap-mutual") == 0) { 549 type = AG_TYPE_CHAP_MUTUAL; 550 } else { 551 if (ag->ag_name != NULL) 552 log_warnx("invalid auth-type \"%s\" for auth-group " 553 "\"%s\"", str, ag->ag_name); 554 else 555 log_warnx("invalid auth-type \"%s\" for target " 556 "\"%s\"", str, ag->ag_target->t_name); 557 return (1); 558 } 559 560 if (ag->ag_type != AG_TYPE_UNKNOWN && ag->ag_type != type) { 561 if (ag->ag_name != NULL) { 562 log_warnx("cannot set auth-type to \"%s\" for " 563 "auth-group \"%s\"; already has a different " 564 "type", str, ag->ag_name); 565 } else { 566 log_warnx("cannot set auth-type to \"%s\" for target " 567 "\"%s\"; already has a different type", 568 str, ag->ag_target->t_name); 569 } 570 return (1); 571 } 572 573 ag->ag_type = type; 574 575 return (0); 576} 577 578static struct portal * 579portal_new(struct portal_group *pg) 580{ 581 struct portal *portal; 582 583 portal = calloc(1, sizeof(*portal)); 584 if (portal == NULL) 585 log_err(1, "calloc"); 586 TAILQ_INIT(&portal->p_targets); 587 portal->p_portal_group = pg; 588 TAILQ_INSERT_TAIL(&pg->pg_portals, portal, p_next); 589 return (portal); 590} 591 592static void 593portal_delete(struct portal *portal) 594{ 595 596 TAILQ_REMOVE(&portal->p_portal_group->pg_portals, portal, p_next); 597 if (portal->p_ai != NULL) 598 freeaddrinfo(portal->p_ai); 599 free(portal->p_listen); 600 free(portal); 601} 602 603struct portal_group * 604portal_group_new(struct conf *conf, const char *name) 605{ 606 struct portal_group *pg; 607 608 pg = portal_group_find(conf, name); 609 if (pg != NULL) { 610 log_warnx("duplicated portal-group \"%s\"", name); 611 return (NULL); 612 } 613 614 pg = calloc(1, sizeof(*pg)); 615 if (pg == NULL) 616 log_err(1, "calloc"); 617 pg->pg_name = checked_strdup(name); 618 TAILQ_INIT(&pg->pg_portals); 619 TAILQ_INIT(&pg->pg_ports); 620 pg->pg_conf = conf; 621 pg->pg_tag = 0; /* Assigned later in conf_apply(). */ 622 TAILQ_INSERT_TAIL(&conf->conf_portal_groups, pg, pg_next); 623 624 return (pg); 625} 626 627void 628portal_group_delete(struct portal_group *pg) 629{ 630 struct portal *portal, *tmp; 631 struct port *port, *tport; 632 633 TAILQ_FOREACH_SAFE(port, &pg->pg_ports, p_pgs, tport) 634 port_delete(port); 635 TAILQ_REMOVE(&pg->pg_conf->conf_portal_groups, pg, pg_next); 636 637 TAILQ_FOREACH_SAFE(portal, &pg->pg_portals, p_next, tmp) 638 portal_delete(portal); 639 free(pg->pg_name); 640 free(pg->pg_redirection); 641 free(pg); 642} 643 644struct portal_group * 645portal_group_find(const struct conf *conf, const char *name) 646{ 647 struct portal_group *pg; 648 649 TAILQ_FOREACH(pg, &conf->conf_portal_groups, pg_next) { 650 if (strcmp(pg->pg_name, name) == 0) 651 return (pg); 652 } 653 654 return (NULL); 655} 656 657static int 658parse_addr_port(char *arg, const char *def_port, struct addrinfo **ai) 659{ 660 struct addrinfo hints; 661 char *str, *addr, *ch; 662 const char *port; 663 int error, colons = 0; 664 665 str = arg = strdup(arg); 666 if (arg[0] == '[') { 667 /* 668 * IPv6 address in square brackets, perhaps with port. 669 */ 670 arg++; 671 addr = strsep(&arg, "]"); 672 if (arg == NULL) 673 return (1); 674 if (arg[0] == '\0') { 675 port = def_port; 676 } else if (arg[0] == ':') { 677 port = arg + 1; 678 } else { 679 free(str); 680 return (1); 681 } 682 } else { 683 /* 684 * Either IPv6 address without brackets - and without 685 * a port - or IPv4 address. Just count the colons. 686 */ 687 for (ch = arg; *ch != '\0'; ch++) { 688 if (*ch == ':') 689 colons++; 690 } 691 if (colons > 1) { 692 addr = arg; 693 port = def_port; 694 } else { 695 addr = strsep(&arg, ":"); 696 if (arg == NULL) 697 port = def_port; 698 else 699 port = arg; 700 } 701 } 702 703 memset(&hints, 0, sizeof(hints)); 704 hints.ai_family = PF_UNSPEC; 705 hints.ai_socktype = SOCK_STREAM; 706 hints.ai_flags = AI_PASSIVE; 707 error = getaddrinfo(addr, port, &hints, ai); 708 free(str); 709 return ((error != 0) ? 1 : 0); 710} 711 712int 713portal_group_add_listen(struct portal_group *pg, const char *value, bool iser) 714{ 715 struct portal *portal; 716 717 portal = portal_new(pg); 718 portal->p_listen = checked_strdup(value); 719 portal->p_iser = iser; 720 721 if (parse_addr_port(portal->p_listen, "3260", &portal->p_ai)) { 722 log_warnx("invalid listen address %s", portal->p_listen); 723 portal_delete(portal); 724 return (1); 725 } 726 727 /* 728 * XXX: getaddrinfo(3) may return multiple addresses; we should turn 729 * those into multiple portals. 730 */ 731 732 return (0); 733} 734 735int 736isns_new(struct conf *conf, const char *addr) 737{ 738 struct isns *isns; 739 740 isns = calloc(1, sizeof(*isns)); 741 if (isns == NULL) 742 log_err(1, "calloc"); 743 isns->i_conf = conf; 744 TAILQ_INSERT_TAIL(&conf->conf_isns, isns, i_next); 745 isns->i_addr = checked_strdup(addr); 746 747 if (parse_addr_port(isns->i_addr, "3205", &isns->i_ai)) { 748 log_warnx("invalid iSNS address %s", isns->i_addr); 749 isns_delete(isns); 750 return (1); 751 } 752 753 /* 754 * XXX: getaddrinfo(3) may return multiple addresses; we should turn 755 * those into multiple servers. 756 */ 757 758 return (0); 759} 760 761void 762isns_delete(struct isns *isns) 763{ 764 765 TAILQ_REMOVE(&isns->i_conf->conf_isns, isns, i_next); 766 free(isns->i_addr); 767 if (isns->i_ai != NULL) 768 freeaddrinfo(isns->i_ai); 769 free(isns); 770} 771 772static int 773isns_do_connect(struct isns *isns) 774{ 775 int s; 776 777 s = socket(isns->i_ai->ai_family, isns->i_ai->ai_socktype, 778 isns->i_ai->ai_protocol); 779 if (s < 0) { 780 log_warn("socket(2) failed for %s", isns->i_addr); 781 return (-1); 782 } 783 if (connect(s, isns->i_ai->ai_addr, isns->i_ai->ai_addrlen)) { 784 log_warn("connect(2) failed for %s", isns->i_addr); 785 close(s); 786 return (-1); 787 } 788 return(s); 789} 790 791static int 792isns_do_register(struct isns *isns, int s, const char *hostname) 793{ 794 struct conf *conf = isns->i_conf; 795 struct target *target; 796 struct portal *portal; 797 struct portal_group *pg; 798 struct port *port; 799 struct isns_req *req; 800 int res = 0; 801 uint32_t error; 802 803 req = isns_req_create(ISNS_FUNC_DEVATTRREG, ISNS_FLAG_CLIENT); 804 isns_req_add_str(req, 32, TAILQ_FIRST(&conf->conf_targets)->t_name); 805 isns_req_add_delim(req); 806 isns_req_add_str(req, 1, hostname); 807 isns_req_add_32(req, 2, 2); /* 2 -- iSCSI */ 808 isns_req_add_32(req, 6, conf->conf_isns_period); 809 TAILQ_FOREACH(pg, &conf->conf_portal_groups, pg_next) { 810 if (pg->pg_unassigned) 811 continue; 812 TAILQ_FOREACH(portal, &pg->pg_portals, p_next) { 813 isns_req_add_addr(req, 16, portal->p_ai); 814 isns_req_add_port(req, 17, portal->p_ai); 815 } 816 } 817 TAILQ_FOREACH(target, &conf->conf_targets, t_next) { 818 isns_req_add_str(req, 32, target->t_name); 819 isns_req_add_32(req, 33, 1); /* 1 -- Target*/ 820 if (target->t_alias != NULL) 821 isns_req_add_str(req, 34, target->t_alias); 822 TAILQ_FOREACH(port, &target->t_ports, p_ts) { 823 if ((pg = port->p_portal_group) == NULL) 824 continue; 825 isns_req_add_32(req, 51, pg->pg_tag); 826 TAILQ_FOREACH(portal, &pg->pg_portals, p_next) { 827 isns_req_add_addr(req, 49, portal->p_ai); 828 isns_req_add_port(req, 50, portal->p_ai); 829 } 830 } 831 } 832 res = isns_req_send(s, req); 833 if (res < 0) { 834 log_warn("send(2) failed for %s", isns->i_addr); 835 goto quit; 836 } 837 res = isns_req_receive(s, req); 838 if (res < 0) { 839 log_warn("receive(2) failed for %s", isns->i_addr); 840 goto quit; 841 } 842 error = isns_req_get_status(req); 843 if (error != 0) { 844 log_warnx("iSNS register error %d for %s", error, isns->i_addr); 845 res = -1; 846 } 847quit: 848 isns_req_free(req); 849 return (res); 850} 851 852static int 853isns_do_check(struct isns *isns, int s, const char *hostname) 854{ 855 struct conf *conf = isns->i_conf; 856 struct isns_req *req; 857 int res = 0; 858 uint32_t error; 859 860 req = isns_req_create(ISNS_FUNC_DEVATTRQRY, ISNS_FLAG_CLIENT); 861 isns_req_add_str(req, 32, TAILQ_FIRST(&conf->conf_targets)->t_name); 862 isns_req_add_str(req, 1, hostname); 863 isns_req_add_delim(req); 864 isns_req_add(req, 2, 0, NULL); 865 res = isns_req_send(s, req); 866 if (res < 0) { 867 log_warn("send(2) failed for %s", isns->i_addr); 868 goto quit; 869 } 870 res = isns_req_receive(s, req); 871 if (res < 0) { 872 log_warn("receive(2) failed for %s", isns->i_addr); 873 goto quit; 874 } 875 error = isns_req_get_status(req); 876 if (error != 0) { 877 log_warnx("iSNS check error %d for %s", error, isns->i_addr); 878 res = -1; 879 } 880quit: 881 isns_req_free(req); 882 return (res); 883} 884 885static int 886isns_do_deregister(struct isns *isns, int s, const char *hostname) 887{ 888 struct conf *conf = isns->i_conf; 889 struct isns_req *req; 890 int res = 0; 891 uint32_t error; 892 893 req = isns_req_create(ISNS_FUNC_DEVDEREG, ISNS_FLAG_CLIENT); 894 isns_req_add_str(req, 32, TAILQ_FIRST(&conf->conf_targets)->t_name); 895 isns_req_add_delim(req); 896 isns_req_add_str(req, 1, hostname); 897 res = isns_req_send(s, req); 898 if (res < 0) { 899 log_warn("send(2) failed for %s", isns->i_addr); 900 goto quit; 901 } 902 res = isns_req_receive(s, req); 903 if (res < 0) { 904 log_warn("receive(2) failed for %s", isns->i_addr); 905 goto quit; 906 } 907 error = isns_req_get_status(req); 908 if (error != 0) { 909 log_warnx("iSNS deregister error %d for %s", error, isns->i_addr); 910 res = -1; 911 } 912quit: 913 isns_req_free(req); 914 return (res); 915} 916 917void 918isns_register(struct isns *isns, struct isns *oldisns) 919{ 920 struct conf *conf = isns->i_conf; 921 int s; 922 char hostname[256]; 923 924 if (TAILQ_EMPTY(&conf->conf_targets) || 925 TAILQ_EMPTY(&conf->conf_portal_groups)) 926 return; 927 set_timeout(conf->conf_isns_timeout, false); 928 s = isns_do_connect(isns); 929 if (s < 0) { 930 set_timeout(0, false); 931 return; 932 } 933 gethostname(hostname, sizeof(hostname)); 934 935 if (oldisns == NULL || TAILQ_EMPTY(&oldisns->i_conf->conf_targets)) 936 oldisns = isns; 937 isns_do_deregister(oldisns, s, hostname); 938 isns_do_register(isns, s, hostname); 939 close(s); 940 set_timeout(0, false); 941} 942 943void 944isns_check(struct isns *isns) 945{ 946 struct conf *conf = isns->i_conf; 947 int s, res; 948 char hostname[256]; 949 950 if (TAILQ_EMPTY(&conf->conf_targets) || 951 TAILQ_EMPTY(&conf->conf_portal_groups)) 952 return; 953 set_timeout(conf->conf_isns_timeout, false); 954 s = isns_do_connect(isns); 955 if (s < 0) { 956 set_timeout(0, false); 957 return; 958 } 959 gethostname(hostname, sizeof(hostname)); 960 961 res = isns_do_check(isns, s, hostname); 962 if (res < 0) { 963 isns_do_deregister(isns, s, hostname); 964 isns_do_register(isns, s, hostname); 965 } 966 close(s); 967 set_timeout(0, false); 968} 969 970void 971isns_deregister(struct isns *isns) 972{ 973 struct conf *conf = isns->i_conf; 974 int s; 975 char hostname[256]; 976 977 if (TAILQ_EMPTY(&conf->conf_targets) || 978 TAILQ_EMPTY(&conf->conf_portal_groups)) 979 return; 980 set_timeout(conf->conf_isns_timeout, false); 981 s = isns_do_connect(isns); 982 if (s < 0) 983 return; 984 gethostname(hostname, sizeof(hostname)); 985 986 isns_do_deregister(isns, s, hostname); 987 close(s); 988 set_timeout(0, false); 989} 990 991int 992portal_group_set_filter(struct portal_group *pg, const char *str) 993{ 994 int filter; 995 996 if (strcmp(str, "none") == 0) { 997 filter = PG_FILTER_NONE; 998 } else if (strcmp(str, "portal") == 0) { 999 filter = PG_FILTER_PORTAL; 1000 } else if (strcmp(str, "portal-name") == 0) { 1001 filter = PG_FILTER_PORTAL_NAME; 1002 } else if (strcmp(str, "portal-name-auth") == 0) { 1003 filter = PG_FILTER_PORTAL_NAME_AUTH; 1004 } else { 1005 log_warnx("invalid discovery-filter \"%s\" for portal-group " 1006 "\"%s\"; valid values are \"none\", \"portal\", " 1007 "\"portal-name\", and \"portal-name-auth\"", 1008 str, pg->pg_name); 1009 return (1); 1010 } 1011 1012 if (pg->pg_discovery_filter != PG_FILTER_UNKNOWN && 1013 pg->pg_discovery_filter != filter) { 1014 log_warnx("cannot set discovery-filter to \"%s\" for " 1015 "portal-group \"%s\"; already has a different " 1016 "value", str, pg->pg_name); 1017 return (1); 1018 } 1019 1020 pg->pg_discovery_filter = filter; 1021 1022 return (0); 1023} 1024 1025int 1026portal_group_set_redirection(struct portal_group *pg, const char *addr) 1027{ 1028 1029 if (pg->pg_redirection != NULL) { 1030 log_warnx("cannot set redirection to \"%s\" for " 1031 "portal-group \"%s\"; already defined", 1032 addr, pg->pg_name); 1033 return (1); 1034 } 1035 1036 pg->pg_redirection = checked_strdup(addr); 1037 1038 return (0); 1039} 1040 1041static bool 1042valid_hex(const char ch) 1043{ 1044 switch (ch) { 1045 case '0': 1046 case '1': 1047 case '2': 1048 case '3': 1049 case '4': 1050 case '5': 1051 case '6': 1052 case '7': 1053 case '8': 1054 case '9': 1055 case 'a': 1056 case 'A': 1057 case 'b': 1058 case 'B': 1059 case 'c': 1060 case 'C': 1061 case 'd': 1062 case 'D': 1063 case 'e': 1064 case 'E': 1065 case 'f': 1066 case 'F': 1067 return (true); 1068 default: 1069 return (false); 1070 } 1071} 1072 1073bool 1074valid_iscsi_name(const char *name) 1075{ 1076 int i; 1077 1078 if (strlen(name) >= MAX_NAME_LEN) { 1079 log_warnx("overlong name for target \"%s\"; max length allowed " 1080 "by iSCSI specification is %d characters", 1081 name, MAX_NAME_LEN); 1082 return (false); 1083 } 1084 1085 /* 1086 * In the cases below, we don't return an error, just in case the admin 1087 * was right, and we're wrong. 1088 */ 1089 if (strncasecmp(name, "iqn.", strlen("iqn.")) == 0) { 1090 for (i = strlen("iqn."); name[i] != '\0'; i++) { 1091 /* 1092 * XXX: We should verify UTF-8 normalisation, as defined 1093 * by 3.2.6.2: iSCSI Name Encoding. 1094 */ 1095 if (isalnum(name[i])) 1096 continue; 1097 if (name[i] == '-' || name[i] == '.' || name[i] == ':') 1098 continue; 1099 log_warnx("invalid character \"%c\" in target name " 1100 "\"%s\"; allowed characters are letters, digits, " 1101 "'-', '.', and ':'", name[i], name); 1102 break; 1103 } 1104 /* 1105 * XXX: Check more stuff: valid date and a valid reversed domain. 1106 */ 1107 } else if (strncasecmp(name, "eui.", strlen("eui.")) == 0) { 1108 if (strlen(name) != strlen("eui.") + 16) 1109 log_warnx("invalid target name \"%s\"; the \"eui.\" " 1110 "should be followed by exactly 16 hexadecimal " 1111 "digits", name); 1112 for (i = strlen("eui."); name[i] != '\0'; i++) { 1113 if (!valid_hex(name[i])) { 1114 log_warnx("invalid character \"%c\" in target " 1115 "name \"%s\"; allowed characters are 1-9 " 1116 "and A-F", name[i], name); 1117 break; 1118 } 1119 } 1120 } else if (strncasecmp(name, "naa.", strlen("naa.")) == 0) { 1121 if (strlen(name) > strlen("naa.") + 32) 1122 log_warnx("invalid target name \"%s\"; the \"naa.\" " 1123 "should be followed by at most 32 hexadecimal " 1124 "digits", name); 1125 for (i = strlen("naa."); name[i] != '\0'; i++) { 1126 if (!valid_hex(name[i])) { 1127 log_warnx("invalid character \"%c\" in target " 1128 "name \"%s\"; allowed characters are 1-9 " 1129 "and A-F", name[i], name); 1130 break; 1131 } 1132 } 1133 } else { 1134 log_warnx("invalid target name \"%s\"; should start with " 1135 "either \"iqn.\", \"eui.\", or \"naa.\"", 1136 name); 1137 } 1138 return (true); 1139} 1140 1141struct pport * 1142pport_new(struct conf *conf, const char *name, uint32_t ctl_port) 1143{ 1144 struct pport *pp; 1145 1146 pp = calloc(1, sizeof(*pp)); 1147 if (pp == NULL) 1148 log_err(1, "calloc"); 1149 pp->pp_conf = conf; 1150 pp->pp_name = checked_strdup(name); 1151 pp->pp_ctl_port = ctl_port; 1152 TAILQ_INIT(&pp->pp_ports); 1153 TAILQ_INSERT_TAIL(&conf->conf_pports, pp, pp_next); 1154 return (pp); 1155} 1156 1157struct pport * 1158pport_find(const struct conf *conf, const char *name) 1159{ 1160 struct pport *pp; 1161 1162 TAILQ_FOREACH(pp, &conf->conf_pports, pp_next) { 1163 if (strcasecmp(pp->pp_name, name) == 0) 1164 return (pp); 1165 } 1166 return (NULL); 1167} 1168 1169struct pport * 1170pport_copy(struct pport *pp, struct conf *conf) 1171{ 1172 struct pport *ppnew; 1173 1174 ppnew = pport_new(conf, pp->pp_name, pp->pp_ctl_port); 1175 return (ppnew); 1176} 1177 1178void 1179pport_delete(struct pport *pp) 1180{ 1181 struct port *port, *tport; 1182 1183 TAILQ_FOREACH_SAFE(port, &pp->pp_ports, p_ts, tport) 1184 port_delete(port); 1185 TAILQ_REMOVE(&pp->pp_conf->conf_pports, pp, pp_next); 1186 free(pp->pp_name); 1187 free(pp); 1188} 1189 1190struct port * 1191port_new(struct conf *conf, struct target *target, struct portal_group *pg) 1192{ 1193 struct port *port; 1194 char *name; 1195 int ret; 1196 1197 ret = asprintf(&name, "%s-%s", pg->pg_name, target->t_name); 1198 if (ret <= 0) 1199 log_err(1, "asprintf"); 1200 if (port_find(conf, name) != NULL) { 1201 log_warnx("duplicate port \"%s\"", name); 1202 free(name); 1203 return (NULL); 1204 } 1205 port = calloc(1, sizeof(*port)); 1206 if (port == NULL) 1207 log_err(1, "calloc"); 1208 port->p_conf = conf; 1209 port->p_name = name; 1210 TAILQ_INSERT_TAIL(&conf->conf_ports, port, p_next); 1211 TAILQ_INSERT_TAIL(&target->t_ports, port, p_ts); 1212 port->p_target = target; 1213 TAILQ_INSERT_TAIL(&pg->pg_ports, port, p_pgs); 1214 port->p_portal_group = pg; 1215 port->p_foreign = pg->pg_foreign; 1216 return (port); 1217} 1218 1219struct port * 1220port_new_pp(struct conf *conf, struct target *target, struct pport *pp) 1221{ 1222 struct port *port; 1223 char *name; 1224 int ret; 1225 1226 ret = asprintf(&name, "%s-%s", pp->pp_name, target->t_name); 1227 if (ret <= 0) 1228 log_err(1, "asprintf"); 1229 if (port_find(conf, name) != NULL) { 1230 log_warnx("duplicate port \"%s\"", name); 1231 free(name); 1232 return (NULL); 1233 } 1234 port = calloc(1, sizeof(*port)); 1235 if (port == NULL) 1236 log_err(1, "calloc"); 1237 port->p_conf = conf; 1238 port->p_name = name; 1239 TAILQ_INSERT_TAIL(&conf->conf_ports, port, p_next); 1240 TAILQ_INSERT_TAIL(&target->t_ports, port, p_ts); 1241 port->p_target = target; 1242 TAILQ_INSERT_TAIL(&pp->pp_ports, port, p_pps); 1243 port->p_pport = pp; 1244 return (port); 1245} 1246 1247struct port * 1248port_find(const struct conf *conf, const char *name) 1249{ 1250 struct port *port; 1251 1252 TAILQ_FOREACH(port, &conf->conf_ports, p_next) { 1253 if (strcasecmp(port->p_name, name) == 0) 1254 return (port); 1255 } 1256 1257 return (NULL); 1258} 1259 1260struct port * 1261port_find_in_pg(const struct portal_group *pg, const char *target) 1262{ 1263 struct port *port; 1264 1265 TAILQ_FOREACH(port, &pg->pg_ports, p_pgs) { 1266 if (strcasecmp(port->p_target->t_name, target) == 0) 1267 return (port); 1268 } 1269 1270 return (NULL); 1271} 1272 1273void 1274port_delete(struct port *port) 1275{ 1276 1277 if (port->p_portal_group) 1278 TAILQ_REMOVE(&port->p_portal_group->pg_ports, port, p_pgs); 1279 if (port->p_pport) 1280 TAILQ_REMOVE(&port->p_pport->pp_ports, port, p_pps); 1281 if (port->p_target) 1282 TAILQ_REMOVE(&port->p_target->t_ports, port, p_ts); 1283 TAILQ_REMOVE(&port->p_conf->conf_ports, port, p_next); 1284 free(port->p_name); 1285 free(port); 1286} 1287 1288struct target * 1289target_new(struct conf *conf, const char *name) 1290{ 1291 struct target *targ; 1292 int i, len; 1293 1294 targ = target_find(conf, name); 1295 if (targ != NULL) { 1296 log_warnx("duplicated target \"%s\"", name); 1297 return (NULL); 1298 } 1299 if (valid_iscsi_name(name) == false) { 1300 log_warnx("target name \"%s\" is invalid", name); 1301 return (NULL); 1302 } 1303 targ = calloc(1, sizeof(*targ)); 1304 if (targ == NULL) 1305 log_err(1, "calloc"); 1306 targ->t_name = checked_strdup(name); 1307 1308 /* 1309 * RFC 3722 requires us to normalize the name to lowercase. 1310 */ 1311 len = strlen(name); 1312 for (i = 0; i < len; i++) 1313 targ->t_name[i] = tolower(targ->t_name[i]); 1314 1315 targ->t_conf = conf; 1316 TAILQ_INIT(&targ->t_ports); 1317 TAILQ_INSERT_TAIL(&conf->conf_targets, targ, t_next); 1318 1319 return (targ); 1320} 1321 1322void 1323target_delete(struct target *targ) 1324{ 1325 struct port *port, *tport; 1326 1327 TAILQ_FOREACH_SAFE(port, &targ->t_ports, p_ts, tport) 1328 port_delete(port); 1329 TAILQ_REMOVE(&targ->t_conf->conf_targets, targ, t_next); 1330 1331 free(targ->t_name); 1332 free(targ->t_redirection); 1333 free(targ); 1334} 1335 1336struct target * 1337target_find(struct conf *conf, const char *name) 1338{ 1339 struct target *targ; 1340 1341 TAILQ_FOREACH(targ, &conf->conf_targets, t_next) { 1342 if (strcasecmp(targ->t_name, name) == 0) 1343 return (targ); 1344 } 1345 1346 return (NULL); 1347} 1348 1349int 1350target_set_redirection(struct target *target, const char *addr) 1351{ 1352 1353 if (target->t_redirection != NULL) { 1354 log_warnx("cannot set redirection to \"%s\" for " 1355 "target \"%s\"; already defined", 1356 addr, target->t_name); 1357 return (1); 1358 } 1359 1360 target->t_redirection = checked_strdup(addr); 1361 1362 return (0); 1363} 1364 1365struct lun * 1366lun_new(struct conf *conf, const char *name) 1367{ 1368 struct lun *lun; 1369 1370 lun = lun_find(conf, name); 1371 if (lun != NULL) { 1372 log_warnx("duplicated lun \"%s\"", name); 1373 return (NULL); 1374 } 1375 1376 lun = calloc(1, sizeof(*lun)); 1377 if (lun == NULL) 1378 log_err(1, "calloc"); 1379 lun->l_conf = conf; 1380 lun->l_name = checked_strdup(name); 1381 TAILQ_INIT(&lun->l_options); 1382 TAILQ_INSERT_TAIL(&conf->conf_luns, lun, l_next); 1383 lun->l_ctl_lun = -1; 1384 1385 return (lun); 1386} 1387 1388void 1389lun_delete(struct lun *lun) 1390{ 1391 struct target *targ; 1392 struct lun_option *lo, *tmp; 1393 int i; 1394 1395 TAILQ_FOREACH(targ, &lun->l_conf->conf_targets, t_next) { 1396 for (i = 0; i < MAX_LUNS; i++) { 1397 if (targ->t_luns[i] == lun) 1398 targ->t_luns[i] = NULL; 1399 } 1400 } 1401 TAILQ_REMOVE(&lun->l_conf->conf_luns, lun, l_next); 1402 1403 TAILQ_FOREACH_SAFE(lo, &lun->l_options, lo_next, tmp) 1404 lun_option_delete(lo); 1405 free(lun->l_name); 1406 free(lun->l_backend); 1407 free(lun->l_device_id); 1408 free(lun->l_path); 1409 free(lun->l_scsiname); 1410 free(lun->l_serial); 1411 free(lun); 1412} 1413 1414struct lun * 1415lun_find(const struct conf *conf, const char *name) 1416{ 1417 struct lun *lun; 1418 1419 TAILQ_FOREACH(lun, &conf->conf_luns, l_next) { 1420 if (strcmp(lun->l_name, name) == 0) 1421 return (lun); 1422 } 1423 1424 return (NULL); 1425} 1426 1427void 1428lun_set_backend(struct lun *lun, const char *value) 1429{ 1430 free(lun->l_backend); 1431 lun->l_backend = checked_strdup(value); 1432} 1433 1434void 1435lun_set_blocksize(struct lun *lun, size_t value) 1436{ 1437 1438 lun->l_blocksize = value; 1439} 1440 1441void 1442lun_set_device_id(struct lun *lun, const char *value) 1443{ 1444 free(lun->l_device_id); 1445 lun->l_device_id = checked_strdup(value); 1446} 1447 1448void 1449lun_set_path(struct lun *lun, const char *value) 1450{ 1451 free(lun->l_path); 1452 lun->l_path = checked_strdup(value); 1453} 1454 1455void 1456lun_set_scsiname(struct lun *lun, const char *value) 1457{ 1458 free(lun->l_scsiname); 1459 lun->l_scsiname = checked_strdup(value); 1460} 1461 1462void 1463lun_set_serial(struct lun *lun, const char *value) 1464{ 1465 free(lun->l_serial); 1466 lun->l_serial = checked_strdup(value); 1467} 1468 1469void 1470lun_set_size(struct lun *lun, size_t value) 1471{ 1472 1473 lun->l_size = value; 1474} 1475 1476void 1477lun_set_ctl_lun(struct lun *lun, uint32_t value) 1478{ 1479 1480 lun->l_ctl_lun = value; 1481} 1482 1483struct lun_option * 1484lun_option_new(struct lun *lun, const char *name, const char *value) 1485{ 1486 struct lun_option *lo; 1487 1488 lo = lun_option_find(lun, name); 1489 if (lo != NULL) { 1490 log_warnx("duplicated lun option \"%s\" for lun \"%s\"", 1491 name, lun->l_name); 1492 return (NULL); 1493 } 1494 1495 lo = calloc(1, sizeof(*lo)); 1496 if (lo == NULL) 1497 log_err(1, "calloc"); 1498 lo->lo_name = checked_strdup(name); 1499 lo->lo_value = checked_strdup(value); 1500 lo->lo_lun = lun; 1501 TAILQ_INSERT_TAIL(&lun->l_options, lo, lo_next); 1502 1503 return (lo); 1504} 1505 1506void 1507lun_option_delete(struct lun_option *lo) 1508{ 1509 1510 TAILQ_REMOVE(&lo->lo_lun->l_options, lo, lo_next); 1511 1512 free(lo->lo_name); 1513 free(lo->lo_value); 1514 free(lo); 1515} 1516 1517struct lun_option * 1518lun_option_find(const struct lun *lun, const char *name) 1519{ 1520 struct lun_option *lo; 1521 1522 TAILQ_FOREACH(lo, &lun->l_options, lo_next) { 1523 if (strcmp(lo->lo_name, name) == 0) 1524 return (lo); 1525 } 1526 1527 return (NULL); 1528} 1529 1530void 1531lun_option_set(struct lun_option *lo, const char *value) 1532{ 1533 1534 free(lo->lo_value); 1535 lo->lo_value = checked_strdup(value); 1536} 1537 1538static struct connection * 1539connection_new(struct portal *portal, int fd, const char *host, 1540 const struct sockaddr *client_sa) 1541{ 1542 struct connection *conn; 1543 1544 conn = calloc(1, sizeof(*conn)); 1545 if (conn == NULL) 1546 log_err(1, "calloc"); 1547 conn->conn_portal = portal; 1548 conn->conn_socket = fd; 1549 conn->conn_initiator_addr = checked_strdup(host); 1550 memcpy(&conn->conn_initiator_sa, client_sa, client_sa->sa_len); 1551 1552 /* 1553 * Default values, from RFC 3720, section 12. 1554 */ 1555 conn->conn_max_data_segment_length = 8192; 1556 conn->conn_max_burst_length = 262144; 1557 conn->conn_immediate_data = true; 1558 1559 return (conn); 1560} 1561 1562#if 0 1563static void 1564conf_print(struct conf *conf) 1565{ 1566 struct auth_group *ag; 1567 struct auth *auth; 1568 struct auth_name *auth_name; 1569 struct auth_portal *auth_portal; 1570 struct portal_group *pg; 1571 struct portal *portal; 1572 struct target *targ; 1573 struct lun *lun; 1574 struct lun_option *lo; 1575 1576 TAILQ_FOREACH(ag, &conf->conf_auth_groups, ag_next) { 1577 fprintf(stderr, "auth-group %s {\n", ag->ag_name); 1578 TAILQ_FOREACH(auth, &ag->ag_auths, a_next) 1579 fprintf(stderr, "\t chap-mutual %s %s %s %s\n", 1580 auth->a_user, auth->a_secret, 1581 auth->a_mutual_user, auth->a_mutual_secret); 1582 TAILQ_FOREACH(auth_name, &ag->ag_names, an_next) 1583 fprintf(stderr, "\t initiator-name %s\n", 1584 auth_name->an_initator_name); 1585 TAILQ_FOREACH(auth_portal, &ag->ag_portals, an_next) 1586 fprintf(stderr, "\t initiator-portal %s\n", 1587 auth_portal->an_initator_portal); 1588 fprintf(stderr, "}\n"); 1589 } 1590 TAILQ_FOREACH(pg, &conf->conf_portal_groups, pg_next) { 1591 fprintf(stderr, "portal-group %s {\n", pg->pg_name); 1592 TAILQ_FOREACH(portal, &pg->pg_portals, p_next) 1593 fprintf(stderr, "\t listen %s\n", portal->p_listen); 1594 fprintf(stderr, "}\n"); 1595 } 1596 TAILQ_FOREACH(lun, &conf->conf_luns, l_next) { 1597 fprintf(stderr, "\tlun %s {\n", lun->l_name); 1598 fprintf(stderr, "\t\tpath %s\n", lun->l_path); 1599 TAILQ_FOREACH(lo, &lun->l_options, lo_next) 1600 fprintf(stderr, "\t\toption %s %s\n", 1601 lo->lo_name, lo->lo_value); 1602 fprintf(stderr, "\t}\n"); 1603 } 1604 TAILQ_FOREACH(targ, &conf->conf_targets, t_next) { 1605 fprintf(stderr, "target %s {\n", targ->t_name); 1606 if (targ->t_alias != NULL) 1607 fprintf(stderr, "\t alias %s\n", targ->t_alias); 1608 fprintf(stderr, "}\n"); 1609 } 1610} 1611#endif 1612 1613static int 1614conf_verify_lun(struct lun *lun) 1615{ 1616 const struct lun *lun2; 1617 1618 if (lun->l_backend == NULL) 1619 lun_set_backend(lun, "block"); 1620 if (strcmp(lun->l_backend, "block") == 0) { 1621 if (lun->l_path == NULL) { 1622 log_warnx("missing path for lun \"%s\"", 1623 lun->l_name); 1624 return (1); 1625 } 1626 } else if (strcmp(lun->l_backend, "ramdisk") == 0) { 1627 if (lun->l_size == 0) { 1628 log_warnx("missing size for ramdisk-backed lun \"%s\"", 1629 lun->l_name); 1630 return (1); 1631 } 1632 if (lun->l_path != NULL) { 1633 log_warnx("path must not be specified " 1634 "for ramdisk-backed lun \"%s\"", 1635 lun->l_name); 1636 return (1); 1637 } 1638 } 1639 if (lun->l_blocksize == 0) { 1640 lun_set_blocksize(lun, DEFAULT_BLOCKSIZE); 1641 } else if (lun->l_blocksize < 0) { 1642 log_warnx("invalid blocksize for lun \"%s\"; " 1643 "must be larger than 0", lun->l_name); 1644 return (1); 1645 } 1646 if (lun->l_size != 0 && lun->l_size % lun->l_blocksize != 0) { 1647 log_warnx("invalid size for lun \"%s\"; " 1648 "must be multiple of blocksize", lun->l_name); 1649 return (1); 1650 } 1651 TAILQ_FOREACH(lun2, &lun->l_conf->conf_luns, l_next) { 1652 if (lun == lun2) 1653 continue; 1654 if (lun->l_path != NULL && lun2->l_path != NULL && 1655 strcmp(lun->l_path, lun2->l_path) == 0) { 1656 log_debugx("WARNING: path \"%s\" duplicated " 1657 "between lun \"%s\", and " 1658 "lun \"%s\"", lun->l_path, 1659 lun->l_name, lun2->l_name); 1660 } 1661 } 1662 1663 return (0); 1664} 1665 1666int 1667conf_verify(struct conf *conf) 1668{ 1669 struct auth_group *ag; 1670 struct portal_group *pg; 1671 struct port *port; 1672 struct target *targ; 1673 struct lun *lun; 1674 bool found; 1675 int error, i; 1676 1677 if (conf->conf_pidfile_path == NULL) 1678 conf->conf_pidfile_path = checked_strdup(DEFAULT_PIDFILE); 1679 1680 TAILQ_FOREACH(lun, &conf->conf_luns, l_next) { 1681 error = conf_verify_lun(lun); 1682 if (error != 0) 1683 return (error); 1684 } 1685 TAILQ_FOREACH(targ, &conf->conf_targets, t_next) { 1686 if (targ->t_auth_group == NULL) { 1687 targ->t_auth_group = auth_group_find(conf, 1688 "default"); 1689 assert(targ->t_auth_group != NULL); 1690 } 1691 if (TAILQ_EMPTY(&targ->t_ports)) { 1692 pg = portal_group_find(conf, "default"); 1693 assert(pg != NULL); 1694 port_new(conf, targ, pg); 1695 } 1696 found = false; 1697 for (i = 0; i < MAX_LUNS; i++) { 1698 if (targ->t_luns[i] != NULL) 1699 found = true; 1700 } 1701 if (!found && targ->t_redirection == NULL) { 1702 log_warnx("no LUNs defined for target \"%s\"", 1703 targ->t_name); 1704 } 1705 if (found && targ->t_redirection != NULL) { 1706 log_debugx("target \"%s\" contains luns, " 1707 " but configured for redirection", 1708 targ->t_name); 1709 } 1710 } 1711 TAILQ_FOREACH(pg, &conf->conf_portal_groups, pg_next) { 1712 assert(pg->pg_name != NULL); 1713 if (pg->pg_discovery_auth_group == NULL) { 1714 pg->pg_discovery_auth_group = 1715 auth_group_find(conf, "default"); 1716 assert(pg->pg_discovery_auth_group != NULL); 1717 } 1718 1719 if (pg->pg_discovery_filter == PG_FILTER_UNKNOWN) 1720 pg->pg_discovery_filter = PG_FILTER_NONE; 1721 1722 if (pg->pg_redirection != NULL) { 1723 if (!TAILQ_EMPTY(&pg->pg_ports)) { 1724 log_debugx("portal-group \"%s\" assigned " 1725 "to target, but configured " 1726 "for redirection", 1727 pg->pg_name); 1728 } 1729 pg->pg_unassigned = false; 1730 } else if (!TAILQ_EMPTY(&pg->pg_ports)) { 1731 pg->pg_unassigned = false; 1732 } else { 1733 if (strcmp(pg->pg_name, "default") != 0) 1734 log_warnx("portal-group \"%s\" not assigned " 1735 "to any target", pg->pg_name); 1736 pg->pg_unassigned = true; 1737 } 1738 } 1739 TAILQ_FOREACH(ag, &conf->conf_auth_groups, ag_next) { 1740 if (ag->ag_name == NULL) 1741 assert(ag->ag_target != NULL); 1742 else 1743 assert(ag->ag_target == NULL); 1744 1745 found = false; 1746 TAILQ_FOREACH(targ, &conf->conf_targets, t_next) { 1747 if (targ->t_auth_group == ag) { 1748 found = true; 1749 break; 1750 } 1751 } 1752 TAILQ_FOREACH(port, &conf->conf_ports, p_next) { 1753 if (port->p_auth_group == ag) { 1754 found = true; 1755 break; 1756 } 1757 } 1758 TAILQ_FOREACH(pg, &conf->conf_portal_groups, pg_next) { 1759 if (pg->pg_discovery_auth_group == ag) { 1760 found = true; 1761 break; 1762 } 1763 } 1764 if (!found && ag->ag_name != NULL && 1765 strcmp(ag->ag_name, "default") != 0 && 1766 strcmp(ag->ag_name, "no-authentication") != 0 && 1767 strcmp(ag->ag_name, "no-access") != 0) { 1768 log_warnx("auth-group \"%s\" not assigned " 1769 "to any target", ag->ag_name); 1770 } 1771 } 1772 1773 return (0); 1774} 1775 1776static int 1777conf_apply(struct conf *oldconf, struct conf *newconf) 1778{ 1779 struct lun *oldlun, *newlun, *tmplun; 1780 struct portal_group *oldpg, *newpg; 1781 struct portal *oldp, *newp; 1782 struct port *oldport, *newport, *tmpport; 1783 struct isns *oldns, *newns; 1784 pid_t otherpid; 1785 int changed, cumulated_error = 0, error, sockbuf; 1786 int one = 1; 1787 1788 if (oldconf->conf_debug != newconf->conf_debug) { 1789 log_debugx("changing debug level to %d", newconf->conf_debug); 1790 log_init(newconf->conf_debug); 1791 } 1792 1793 if (oldconf->conf_pidfh != NULL) { 1794 assert(oldconf->conf_pidfile_path != NULL); 1795 if (newconf->conf_pidfile_path != NULL && 1796 strcmp(oldconf->conf_pidfile_path, 1797 newconf->conf_pidfile_path) == 0) { 1798 newconf->conf_pidfh = oldconf->conf_pidfh; 1799 oldconf->conf_pidfh = NULL; 1800 } else { 1801 log_debugx("removing pidfile %s", 1802 oldconf->conf_pidfile_path); 1803 pidfile_remove(oldconf->conf_pidfh); 1804 oldconf->conf_pidfh = NULL; 1805 } 1806 } 1807 1808 if (newconf->conf_pidfh == NULL && newconf->conf_pidfile_path != NULL) { 1809 log_debugx("opening pidfile %s", newconf->conf_pidfile_path); 1810 newconf->conf_pidfh = 1811 pidfile_open(newconf->conf_pidfile_path, 0600, &otherpid); 1812 if (newconf->conf_pidfh == NULL) { 1813 if (errno == EEXIST) 1814 log_errx(1, "daemon already running, pid: %jd.", 1815 (intmax_t)otherpid); 1816 log_err(1, "cannot open or create pidfile \"%s\"", 1817 newconf->conf_pidfile_path); 1818 } 1819 } 1820 1821 /* 1822 * Go through the new portal groups, assigning tags or preserving old. 1823 */ 1824 TAILQ_FOREACH(newpg, &newconf->conf_portal_groups, pg_next) { 1825 if (newpg->pg_tag != 0) 1826 continue; 1827 oldpg = portal_group_find(oldconf, newpg->pg_name); 1828 if (oldpg != NULL) 1829 newpg->pg_tag = oldpg->pg_tag; 1830 else 1831 newpg->pg_tag = ++last_portal_group_tag; 1832 } 1833 1834 /* Deregister on removed iSNS servers. */ 1835 TAILQ_FOREACH(oldns, &oldconf->conf_isns, i_next) { 1836 TAILQ_FOREACH(newns, &newconf->conf_isns, i_next) { 1837 if (strcmp(oldns->i_addr, newns->i_addr) == 0) 1838 break; 1839 } 1840 if (newns == NULL) 1841 isns_deregister(oldns); 1842 } 1843 1844 /* 1845 * XXX: If target or lun removal fails, we should somehow "move" 1846 * the old lun or target into newconf, so that subsequent 1847 * conf_apply() would try to remove them again. That would 1848 * be somewhat hairy, though, and lun deletion failures don't 1849 * really happen, so leave it as it is for now. 1850 */ 1851 /* 1852 * First, remove any ports present in the old configuration 1853 * and missing in the new one. 1854 */ 1855 TAILQ_FOREACH_SAFE(oldport, &oldconf->conf_ports, p_next, tmpport) { 1856 if (oldport->p_foreign) 1857 continue; 1858 newport = port_find(newconf, oldport->p_name); 1859 if (newport != NULL && !newport->p_foreign) 1860 continue; 1861 log_debugx("removing port \"%s\"", oldport->p_name); 1862 error = kernel_port_remove(oldport); 1863 if (error != 0) { 1864 log_warnx("failed to remove port %s", 1865 oldport->p_name); 1866 /* 1867 * XXX: Uncomment after fixing the root cause. 1868 * 1869 * cumulated_error++; 1870 */ 1871 } 1872 } 1873 1874 /* 1875 * Second, remove any LUNs present in the old configuration 1876 * and missing in the new one. 1877 */ 1878 TAILQ_FOREACH_SAFE(oldlun, &oldconf->conf_luns, l_next, tmplun) { 1879 newlun = lun_find(newconf, oldlun->l_name); 1880 if (newlun == NULL) { 1881 log_debugx("lun \"%s\", CTL lun %d " 1882 "not found in new configuration; " 1883 "removing", oldlun->l_name, oldlun->l_ctl_lun); 1884 error = kernel_lun_remove(oldlun); 1885 if (error != 0) { 1886 log_warnx("failed to remove lun \"%s\", " 1887 "CTL lun %d", 1888 oldlun->l_name, oldlun->l_ctl_lun); 1889 cumulated_error++; 1890 } 1891 continue; 1892 } 1893 1894 /* 1895 * Also remove the LUNs changed by more than size. 1896 */ 1897 changed = 0; 1898 assert(oldlun->l_backend != NULL); 1899 assert(newlun->l_backend != NULL); 1900 if (strcmp(newlun->l_backend, oldlun->l_backend) != 0) { 1901 log_debugx("backend for lun \"%s\", " 1902 "CTL lun %d changed; removing", 1903 oldlun->l_name, oldlun->l_ctl_lun); 1904 changed = 1; 1905 } 1906 if (oldlun->l_blocksize != newlun->l_blocksize) { 1907 log_debugx("blocksize for lun \"%s\", " 1908 "CTL lun %d changed; removing", 1909 oldlun->l_name, oldlun->l_ctl_lun); 1910 changed = 1; 1911 } 1912 if (newlun->l_device_id != NULL && 1913 (oldlun->l_device_id == NULL || 1914 strcmp(oldlun->l_device_id, newlun->l_device_id) != 1915 0)) { 1916 log_debugx("device-id for lun \"%s\", " 1917 "CTL lun %d changed; removing", 1918 oldlun->l_name, oldlun->l_ctl_lun); 1919 changed = 1; 1920 } 1921 if (newlun->l_path != NULL && 1922 (oldlun->l_path == NULL || 1923 strcmp(oldlun->l_path, newlun->l_path) != 0)) { 1924 log_debugx("path for lun \"%s\", " 1925 "CTL lun %d, changed; removing", 1926 oldlun->l_name, oldlun->l_ctl_lun); 1927 changed = 1; 1928 } 1929 if (newlun->l_serial != NULL && 1930 (oldlun->l_serial == NULL || 1931 strcmp(oldlun->l_serial, newlun->l_serial) != 0)) { 1932 log_debugx("serial for lun \"%s\", " 1933 "CTL lun %d changed; removing", 1934 oldlun->l_name, oldlun->l_ctl_lun); 1935 changed = 1; 1936 } 1937 if (changed) { 1938 error = kernel_lun_remove(oldlun); 1939 if (error != 0) { 1940 log_warnx("failed to remove lun \"%s\", " 1941 "CTL lun %d", 1942 oldlun->l_name, oldlun->l_ctl_lun); 1943 cumulated_error++; 1944 } 1945 lun_delete(oldlun); 1946 continue; 1947 } 1948 1949 lun_set_ctl_lun(newlun, oldlun->l_ctl_lun); 1950 } 1951 1952 TAILQ_FOREACH_SAFE(newlun, &newconf->conf_luns, l_next, tmplun) { 1953 oldlun = lun_find(oldconf, newlun->l_name); 1954 if (oldlun != NULL) { 1955 log_debugx("modifying lun \"%s\", CTL lun %d", 1956 newlun->l_name, newlun->l_ctl_lun); 1957 error = kernel_lun_modify(newlun); 1958 if (error != 0) { 1959 log_warnx("failed to " 1960 "modify lun \"%s\", CTL lun %d", 1961 newlun->l_name, newlun->l_ctl_lun); 1962 cumulated_error++; 1963 } 1964 continue; 1965 } 1966 log_debugx("adding lun \"%s\"", newlun->l_name); 1967 error = kernel_lun_add(newlun); 1968 if (error != 0) { 1969 log_warnx("failed to add lun \"%s\"", newlun->l_name); 1970 lun_delete(newlun); 1971 cumulated_error++; 1972 } 1973 } 1974 1975 /* 1976 * Now add new ports or modify existing ones. 1977 */ 1978 TAILQ_FOREACH(newport, &newconf->conf_ports, p_next) { 1979 if (newport->p_foreign) 1980 continue; 1981 oldport = port_find(oldconf, newport->p_name); 1982 1983 if (oldport == NULL || oldport->p_foreign) { 1984 log_debugx("adding port \"%s\"", newport->p_name); 1985 error = kernel_port_add(newport); 1986 } else { 1987 log_debugx("updating port \"%s\"", newport->p_name); 1988 newport->p_ctl_port = oldport->p_ctl_port; 1989 error = kernel_port_update(newport, oldport); 1990 } 1991 if (error != 0) { 1992 log_warnx("failed to %s port %s", 1993 (oldport == NULL) ? "add" : "update", 1994 newport->p_name); 1995 /* 1996 * XXX: Uncomment after fixing the root cause. 1997 * 1998 * cumulated_error++; 1999 */ 2000 } 2001 } 2002 2003 /* 2004 * Go through the new portals, opening the sockets as neccessary. 2005 */ 2006 TAILQ_FOREACH(newpg, &newconf->conf_portal_groups, pg_next) { 2007 if (newpg->pg_foreign) 2008 continue; 2009 if (newpg->pg_unassigned) { 2010 log_debugx("not listening on portal-group \"%s\", " 2011 "not assigned to any target", 2012 newpg->pg_name); 2013 continue; 2014 } 2015 TAILQ_FOREACH(newp, &newpg->pg_portals, p_next) { 2016 /* 2017 * Try to find already open portal and reuse 2018 * the listening socket. We don't care about 2019 * what portal or portal group that was, what 2020 * matters is the listening address. 2021 */ 2022 TAILQ_FOREACH(oldpg, &oldconf->conf_portal_groups, 2023 pg_next) { 2024 TAILQ_FOREACH(oldp, &oldpg->pg_portals, 2025 p_next) { 2026 if (strcmp(newp->p_listen, 2027 oldp->p_listen) == 0 && 2028 oldp->p_socket > 0) { 2029 newp->p_socket = 2030 oldp->p_socket; 2031 oldp->p_socket = 0; 2032 break; 2033 } 2034 } 2035 } 2036 if (newp->p_socket > 0) { 2037 /* 2038 * We're done with this portal. 2039 */ 2040 continue; 2041 } 2042 2043#ifdef ICL_KERNEL_PROXY 2044 if (proxy_mode) { 2045 newpg->pg_conf->conf_portal_id++; 2046 newp->p_id = newpg->pg_conf->conf_portal_id; 2047 log_debugx("listening on %s, portal-group " 2048 "\"%s\", portal id %d, using ICL proxy", 2049 newp->p_listen, newpg->pg_name, newp->p_id); 2050 kernel_listen(newp->p_ai, newp->p_iser, 2051 newp->p_id); 2052 continue; 2053 } 2054#endif 2055 assert(proxy_mode == false); 2056 assert(newp->p_iser == false); 2057 2058 log_debugx("listening on %s, portal-group \"%s\"", 2059 newp->p_listen, newpg->pg_name); 2060 newp->p_socket = socket(newp->p_ai->ai_family, 2061 newp->p_ai->ai_socktype, 2062 newp->p_ai->ai_protocol); 2063 if (newp->p_socket < 0) { 2064 log_warn("socket(2) failed for %s", 2065 newp->p_listen); 2066 cumulated_error++; 2067 continue; 2068 } 2069 sockbuf = SOCKBUF_SIZE; 2070 if (setsockopt(newp->p_socket, SOL_SOCKET, SO_RCVBUF, 2071 &sockbuf, sizeof(sockbuf)) == -1) 2072 log_warn("setsockopt(SO_RCVBUF) failed " 2073 "for %s", newp->p_listen); 2074 sockbuf = SOCKBUF_SIZE; 2075 if (setsockopt(newp->p_socket, SOL_SOCKET, SO_SNDBUF, 2076 &sockbuf, sizeof(sockbuf)) == -1) 2077 log_warn("setsockopt(SO_SNDBUF) failed " 2078 "for %s", newp->p_listen); 2079 error = setsockopt(newp->p_socket, SOL_SOCKET, 2080 SO_REUSEADDR, &one, sizeof(one)); 2081 if (error != 0) { 2082 log_warn("setsockopt(SO_REUSEADDR) failed " 2083 "for %s", newp->p_listen); 2084 close(newp->p_socket); 2085 newp->p_socket = 0; 2086 cumulated_error++; 2087 continue; 2088 } 2089 error = bind(newp->p_socket, newp->p_ai->ai_addr, 2090 newp->p_ai->ai_addrlen); 2091 if (error != 0) { 2092 log_warn("bind(2) failed for %s", 2093 newp->p_listen); 2094 close(newp->p_socket); 2095 newp->p_socket = 0; 2096 cumulated_error++; 2097 continue; 2098 } 2099 error = listen(newp->p_socket, -1); 2100 if (error != 0) { 2101 log_warn("listen(2) failed for %s", 2102 newp->p_listen); 2103 close(newp->p_socket); 2104 newp->p_socket = 0; 2105 cumulated_error++; 2106 continue; 2107 } 2108 } 2109 } 2110 2111 /* 2112 * Go through the no longer used sockets, closing them. 2113 */ 2114 TAILQ_FOREACH(oldpg, &oldconf->conf_portal_groups, pg_next) { 2115 TAILQ_FOREACH(oldp, &oldpg->pg_portals, p_next) { 2116 if (oldp->p_socket <= 0) 2117 continue; 2118 log_debugx("closing socket for %s, portal-group \"%s\"", 2119 oldp->p_listen, oldpg->pg_name); 2120 close(oldp->p_socket); 2121 oldp->p_socket = 0; 2122 } 2123 } 2124 2125 /* (Re-)Register on remaining/new iSNS servers. */ 2126 TAILQ_FOREACH(newns, &newconf->conf_isns, i_next) { 2127 TAILQ_FOREACH(oldns, &oldconf->conf_isns, i_next) { 2128 if (strcmp(oldns->i_addr, newns->i_addr) == 0) 2129 break; 2130 } 2131 isns_register(newns, oldns); 2132 } 2133 2134 /* Schedule iSNS update */ 2135 if (!TAILQ_EMPTY(&newconf->conf_isns)) 2136 set_timeout((newconf->conf_isns_period + 2) / 3, false); 2137 2138 return (cumulated_error); 2139} 2140 2141bool 2142timed_out(void) 2143{ 2144 2145 return (sigalrm_received); 2146} 2147 2148static void 2149sigalrm_handler_fatal(int dummy __unused) 2150{ 2151 /* 2152 * It would be easiest to just log an error and exit. We can't 2153 * do this, though, because log_errx() is not signal safe, since 2154 * it calls syslog(3). Instead, set a flag checked by pdu_send() 2155 * and pdu_receive(), to call log_errx() there. Should they fail 2156 * to notice, we'll exit here one second later. 2157 */ 2158 if (sigalrm_received) { 2159 /* 2160 * Oh well. Just give up and quit. 2161 */ 2162 _exit(2); 2163 } 2164 2165 sigalrm_received = true; 2166} 2167 2168static void 2169sigalrm_handler(int dummy __unused) 2170{ 2171 2172 sigalrm_received = true; 2173} 2174 2175void 2176set_timeout(int timeout, int fatal) 2177{ 2178 struct sigaction sa; 2179 struct itimerval itv; 2180 int error; 2181 2182 if (timeout <= 0) { 2183 log_debugx("session timeout disabled"); 2184 bzero(&itv, sizeof(itv)); 2185 error = setitimer(ITIMER_REAL, &itv, NULL); 2186 if (error != 0) 2187 log_err(1, "setitimer"); 2188 sigalrm_received = false; 2189 return; 2190 } 2191 2192 sigalrm_received = false; 2193 bzero(&sa, sizeof(sa)); 2194 if (fatal) 2195 sa.sa_handler = sigalrm_handler_fatal; 2196 else 2197 sa.sa_handler = sigalrm_handler; 2198 sigfillset(&sa.sa_mask); 2199 error = sigaction(SIGALRM, &sa, NULL); 2200 if (error != 0) 2201 log_err(1, "sigaction"); 2202 2203 /* 2204 * First SIGALRM will arive after conf_timeout seconds. 2205 * If we do nothing, another one will arrive a second later. 2206 */ 2207 log_debugx("setting session timeout to %d seconds", timeout); 2208 bzero(&itv, sizeof(itv)); 2209 itv.it_interval.tv_sec = 1; 2210 itv.it_value.tv_sec = timeout; 2211 error = setitimer(ITIMER_REAL, &itv, NULL); 2212 if (error != 0) 2213 log_err(1, "setitimer"); 2214} 2215 2216static int 2217wait_for_children(bool block) 2218{ 2219 pid_t pid; 2220 int status; 2221 int num = 0; 2222 2223 for (;;) { 2224 /* 2225 * If "block" is true, wait for at least one process. 2226 */ 2227 if (block && num == 0) 2228 pid = wait4(-1, &status, 0, NULL); 2229 else 2230 pid = wait4(-1, &status, WNOHANG, NULL); 2231 if (pid <= 0) 2232 break; 2233 if (WIFSIGNALED(status)) { 2234 log_warnx("child process %d terminated with signal %d", 2235 pid, WTERMSIG(status)); 2236 } else if (WEXITSTATUS(status) != 0) { 2237 log_warnx("child process %d terminated with exit status %d", 2238 pid, WEXITSTATUS(status)); 2239 } else { 2240 log_debugx("child process %d terminated gracefully", pid); 2241 } 2242 num++; 2243 } 2244 2245 return (num); 2246} 2247 2248static void 2249handle_connection(struct portal *portal, int fd, 2250 const struct sockaddr *client_sa, bool dont_fork) 2251{ 2252 struct connection *conn; 2253 int error; 2254 pid_t pid; 2255 char host[NI_MAXHOST + 1]; 2256 struct conf *conf; 2257 2258 conf = portal->p_portal_group->pg_conf; 2259 2260 if (dont_fork) { 2261 log_debugx("incoming connection; not forking due to -d flag"); 2262 } else { 2263 nchildren -= wait_for_children(false); 2264 assert(nchildren >= 0); 2265 2266 while (conf->conf_maxproc > 0 && nchildren >= conf->conf_maxproc) { 2267 log_debugx("maxproc limit of %d child processes hit; " 2268 "waiting for child process to exit", conf->conf_maxproc); 2269 nchildren -= wait_for_children(true); 2270 assert(nchildren >= 0); 2271 } 2272 log_debugx("incoming connection; forking child process #%d", 2273 nchildren); 2274 nchildren++; 2275 pid = fork(); 2276 if (pid < 0) 2277 log_err(1, "fork"); 2278 if (pid > 0) { 2279 close(fd); 2280 return; 2281 } 2282 } 2283 pidfile_close(conf->conf_pidfh); 2284 2285 error = getnameinfo(client_sa, client_sa->sa_len, 2286 host, sizeof(host), NULL, 0, NI_NUMERICHOST); 2287 if (error != 0) 2288 log_errx(1, "getnameinfo: %s", gai_strerror(error)); 2289 2290 log_debugx("accepted connection from %s; portal group \"%s\"", 2291 host, portal->p_portal_group->pg_name); 2292 log_set_peer_addr(host); 2293 setproctitle("%s", host); 2294 2295 conn = connection_new(portal, fd, host, client_sa); 2296 set_timeout(conf->conf_timeout, true); 2297 kernel_capsicate(); 2298 login(conn); 2299 if (conn->conn_session_type == CONN_SESSION_TYPE_NORMAL) { 2300 kernel_handoff(conn); 2301 log_debugx("connection handed off to the kernel"); 2302 } else { 2303 assert(conn->conn_session_type == CONN_SESSION_TYPE_DISCOVERY); 2304 discovery(conn); 2305 } 2306 log_debugx("nothing more to do; exiting"); 2307 exit(0); 2308} 2309 2310static int 2311fd_add(int fd, fd_set *fdset, int nfds) 2312{ 2313 2314 /* 2315 * Skip sockets which we failed to bind. 2316 */ 2317 if (fd <= 0) 2318 return (nfds); 2319 2320 FD_SET(fd, fdset); 2321 if (fd > nfds) 2322 nfds = fd; 2323 return (nfds); 2324} 2325 2326static void 2327main_loop(struct conf *conf, bool dont_fork) 2328{ 2329 struct portal_group *pg; 2330 struct portal *portal; 2331 struct sockaddr_storage client_sa; 2332 socklen_t client_salen; 2333#ifdef ICL_KERNEL_PROXY 2334 int connection_id; 2335 int portal_id; 2336#endif 2337 fd_set fdset; 2338 int error, nfds, client_fd; 2339 2340 pidfile_write(conf->conf_pidfh); 2341 2342 for (;;) { 2343 if (sighup_received || sigterm_received || timed_out()) 2344 return; 2345 2346#ifdef ICL_KERNEL_PROXY 2347 if (proxy_mode) { 2348 client_salen = sizeof(client_sa); 2349 kernel_accept(&connection_id, &portal_id, 2350 (struct sockaddr *)&client_sa, &client_salen); 2351 assert(client_salen >= client_sa.ss_len); 2352 2353 log_debugx("incoming connection, id %d, portal id %d", 2354 connection_id, portal_id); 2355 TAILQ_FOREACH(pg, &conf->conf_portal_groups, pg_next) { 2356 TAILQ_FOREACH(portal, &pg->pg_portals, p_next) { 2357 if (portal->p_id == portal_id) { 2358 goto found; 2359 } 2360 } 2361 } 2362 2363 log_errx(1, "kernel returned invalid portal_id %d", 2364 portal_id); 2365 2366found: 2367 handle_connection(portal, connection_id, 2368 (struct sockaddr *)&client_sa, dont_fork); 2369 } else { 2370#endif 2371 assert(proxy_mode == false); 2372 2373 FD_ZERO(&fdset); 2374 nfds = 0; 2375 TAILQ_FOREACH(pg, &conf->conf_portal_groups, pg_next) { 2376 TAILQ_FOREACH(portal, &pg->pg_portals, p_next) 2377 nfds = fd_add(portal->p_socket, &fdset, nfds); 2378 } 2379 error = select(nfds + 1, &fdset, NULL, NULL, NULL); 2380 if (error <= 0) { 2381 if (errno == EINTR) 2382 return; 2383 log_err(1, "select"); 2384 } 2385 TAILQ_FOREACH(pg, &conf->conf_portal_groups, pg_next) { 2386 TAILQ_FOREACH(portal, &pg->pg_portals, p_next) { 2387 if (!FD_ISSET(portal->p_socket, &fdset)) 2388 continue; 2389 client_salen = sizeof(client_sa); 2390 client_fd = accept(portal->p_socket, 2391 (struct sockaddr *)&client_sa, 2392 &client_salen); 2393 if (client_fd < 0) { 2394 if (errno == ECONNABORTED) 2395 continue; 2396 log_err(1, "accept"); 2397 } 2398 assert(client_salen >= client_sa.ss_len); 2399 2400 handle_connection(portal, client_fd, 2401 (struct sockaddr *)&client_sa, 2402 dont_fork); 2403 break; 2404 } 2405 } 2406#ifdef ICL_KERNEL_PROXY 2407 } 2408#endif 2409 } 2410} 2411 2412static void 2413sighup_handler(int dummy __unused) 2414{ 2415 2416 sighup_received = true; 2417} 2418 2419static void 2420sigterm_handler(int dummy __unused) 2421{ 2422 2423 sigterm_received = true; 2424} 2425 2426static void 2427sigchld_handler(int dummy __unused) 2428{ 2429 2430 /* 2431 * The only purpose of this handler is to make SIGCHLD 2432 * interrupt the ISCSIDWAIT ioctl(2), so we can call 2433 * wait_for_children(). 2434 */ 2435} 2436 2437static void 2438register_signals(void) 2439{ 2440 struct sigaction sa; 2441 int error; 2442 2443 bzero(&sa, sizeof(sa)); 2444 sa.sa_handler = sighup_handler; 2445 sigfillset(&sa.sa_mask); 2446 error = sigaction(SIGHUP, &sa, NULL); 2447 if (error != 0) 2448 log_err(1, "sigaction"); 2449 2450 sa.sa_handler = sigterm_handler; 2451 error = sigaction(SIGTERM, &sa, NULL); 2452 if (error != 0) 2453 log_err(1, "sigaction"); 2454 2455 sa.sa_handler = sigterm_handler; 2456 error = sigaction(SIGINT, &sa, NULL); 2457 if (error != 0) 2458 log_err(1, "sigaction"); 2459 2460 sa.sa_handler = sigchld_handler; 2461 error = sigaction(SIGCHLD, &sa, NULL); 2462 if (error != 0) 2463 log_err(1, "sigaction"); 2464} 2465 2466int 2467main(int argc, char **argv) 2468{ 2469 struct conf *oldconf, *newconf, *tmpconf; 2470 struct isns *newns; 2471 const char *config_path = DEFAULT_CONFIG_PATH; 2472 int debug = 0, ch, error; 2473 bool dont_daemonize = false; 2474 2475 while ((ch = getopt(argc, argv, "df:R")) != -1) { 2476 switch (ch) { 2477 case 'd': 2478 dont_daemonize = true; 2479 debug++; 2480 break; 2481 case 'f': 2482 config_path = optarg; 2483 break; 2484 case 'R': 2485#ifndef ICL_KERNEL_PROXY 2486 log_errx(1, "ctld(8) compiled without ICL_KERNEL_PROXY " 2487 "does not support iSER protocol"); 2488#endif 2489 proxy_mode = true; 2490 break; 2491 case '?': 2492 default: 2493 usage(); 2494 } 2495 } 2496 argc -= optind; 2497 if (argc != 0) 2498 usage(); 2499 2500 log_init(debug); 2501 kernel_init(); 2502 2503 oldconf = conf_new_from_kernel(); 2504 newconf = conf_new_from_file(config_path, oldconf); 2505 if (newconf == NULL) 2506 log_errx(1, "configuration error; exiting"); 2507 if (debug > 0) { 2508 oldconf->conf_debug = debug; 2509 newconf->conf_debug = debug; 2510 } 2511 2512 error = conf_apply(oldconf, newconf); 2513 if (error != 0) 2514 log_errx(1, "failed to apply configuration; exiting"); 2515 2516 conf_delete(oldconf); 2517 oldconf = NULL; 2518 2519 register_signals(); 2520 2521 if (dont_daemonize == false) { 2522 log_debugx("daemonizing"); 2523 if (daemon(0, 0) == -1) { 2524 log_warn("cannot daemonize"); 2525 pidfile_remove(newconf->conf_pidfh); 2526 exit(1); 2527 } 2528 } 2529 2530 /* Schedule iSNS update */ 2531 if (!TAILQ_EMPTY(&newconf->conf_isns)) 2532 set_timeout((newconf->conf_isns_period + 2) / 3, false); 2533 2534 for (;;) { 2535 main_loop(newconf, dont_daemonize); 2536 if (sighup_received) { 2537 sighup_received = false; 2538 log_debugx("received SIGHUP, reloading configuration"); 2539 tmpconf = conf_new_from_file(config_path, newconf); 2540 if (tmpconf == NULL) { 2541 log_warnx("configuration error, " 2542 "continuing with old configuration"); 2543 } else { 2544 if (debug > 0) 2545 tmpconf->conf_debug = debug; 2546 oldconf = newconf; 2547 newconf = tmpconf; 2548 error = conf_apply(oldconf, newconf); 2549 if (error != 0) 2550 log_warnx("failed to reload " 2551 "configuration"); 2552 conf_delete(oldconf); 2553 oldconf = NULL; 2554 } 2555 } else if (sigterm_received) { 2556 log_debugx("exiting on signal; " 2557 "reloading empty configuration"); 2558 2559 log_debugx("removing CTL iSCSI ports " 2560 "and terminating all connections"); 2561 2562 oldconf = newconf; 2563 newconf = conf_new(); 2564 if (debug > 0) 2565 newconf->conf_debug = debug; 2566 error = conf_apply(oldconf, newconf); 2567 if (error != 0) 2568 log_warnx("failed to apply configuration"); 2569 conf_delete(oldconf); 2570 oldconf = NULL; 2571 2572 log_warnx("exiting on signal"); 2573 exit(0); 2574 } else { 2575 nchildren -= wait_for_children(false); 2576 assert(nchildren >= 0); 2577 if (timed_out()) { 2578 set_timeout(0, false); 2579 TAILQ_FOREACH(newns, &newconf->conf_isns, i_next) 2580 isns_check(newns); 2581 /* Schedule iSNS update */ 2582 if (!TAILQ_EMPTY(&newconf->conf_isns)) { 2583 set_timeout((newconf->conf_isns_period 2584 + 2) / 3, 2585 false); 2586 } 2587 } 2588 } 2589 } 2590 /* NOTREACHED */ 2591} 2592