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