usr.sbin/ctld/ctld.c

   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  * $FreeBSD$
  30  */
  31
  32 #include <sys/types.h>
  33 #include <sys/time.h>
  34 #include <sys/socket.h>
  35 #include <sys/wait.h>
  36 #include <netinet/in.h>
  37 #include <assert.h>
  38 #include <ctype.h>
  39 #include <errno.h>
  40 #include <netdb.h>
  41 #include <signal.h>
  42 #include <stdbool.h>
  43 #include <stdio.h>
  44 #include <stdint.h>
  45 #include <stdlib.h>
  46 #include <string.h>
  47 #include <unistd.h>
  48
  49 #include "ctld.h"
  50
  51 static volatile bool sighup_received = false;
  52 static volatile bool sigterm_received = false;
  53 static volatile bool sigalrm_received = false;
  54
  55 static int nchildren = 0;
  56
  57 static void
  58 usage(void)
  59 {
  60
  61         fprintf(stderr, "usage: ctld [-d][-f config-file]\n");
  62         exit(1);
  63 }
  64
  65 char *
  66 checked_strdup(const char *s)
  67 {
  68         char *c;
  69
  70         c = strdup(s);
  71         if (c == NULL)
  72                 log_err(1, "strdup");
  73         return (c);
  74 }
  75
  76 struct conf *
  77 conf_new(void)
  78 {
  79         struct conf *conf;
  80
  81         conf = calloc(1, sizeof(*conf));
  82         if (conf == NULL)
  83                 log_err(1, "calloc");
  84         TAILQ_INIT(&conf->conf_targets);
  85         TAILQ_INIT(&conf->conf_auth_groups);
  86         TAILQ_INIT(&conf->conf_portal_groups);
  87
  88         conf->conf_debug = 0;
  89         conf->conf_timeout = 60;
  90         conf->conf_maxproc = 30;
  91
  92         return (conf);
  93 }
  94
  95 void
  96 conf_delete(struct conf *conf)
  97 {
  98         struct target *targ, *tmp;
  99         struct auth_group *ag, *cagtmp;
 100         struct portal_group *pg, *cpgtmp;
 101
 102         assert(conf->conf_pidfh == NULL);
 103
 104         TAILQ_FOREACH_SAFE(targ, &conf->conf_targets, t_next, tmp)
 105                 target_delete(targ);
 106         TAILQ_FOREACH_SAFE(ag, &conf->conf_auth_groups, ag_next, cagtmp)
 107                 auth_group_delete(ag);
 108         TAILQ_FOREACH_SAFE(pg, &conf->conf_portal_groups, pg_next, cpgtmp)
 109                 portal_group_delete(pg);
 110         free(conf->conf_pidfile_path);
 111         free(conf);
 112 }
 113
 114 static struct auth *
 115 auth_new(struct auth_group *ag)
 116 {
 117         struct auth *auth;
 118
 119         auth = calloc(1, sizeof(*auth));
 120         if (auth == NULL)
 121                 log_err(1, "calloc");
 122         auth->a_auth_group = ag;
 123         TAILQ_INSERT_TAIL(&ag->ag_auths, auth, a_next);
 124         return (auth);
 125 }
 126
 127 static void
 128 auth_delete(struct auth *auth)
 129 {
 130         TAILQ_REMOVE(&auth->a_auth_group->ag_auths, auth, a_next);
 131
 132         free(auth->a_user);
 133         free(auth->a_secret);
 134         free(auth->a_mutual_user);
 135         free(auth->a_mutual_secret);
 136         free(auth);
 137 }
 138
 139 const struct auth *
 140 auth_find(struct auth_group *ag, const char *user)
 141 {
 142         const struct auth *auth;
 143
 144         TAILQ_FOREACH(auth, &ag->ag_auths, a_next) {
 145                 if (strcmp(auth->a_user, user) == 0)
 146                         return (auth);
 147         }
 148
 149         return (NULL);
 150 }
 151
 152 const struct auth_name *
 153 auth_name_new(struct auth_group *ag, const char *name)
 154 {
 155         struct auth_name *an;
 156
 157         an = calloc(1, sizeof(*an));
 158         if (an == NULL)
 159                 log_err(1, "calloc");
 160         an->an_auth_group = ag;
 161         an->an_initator_name = checked_strdup(name);
 162         TAILQ_INSERT_TAIL(&ag->ag_names, an, an_next);
 163         return (an);
 164 }
 165
 166 static void
 167 auth_name_delete(struct auth_name *an)
 168 {
 169         TAILQ_REMOVE(&an->an_auth_group->ag_names, an, an_next);
 170
 171         free(an->an_initator_name);
 172         free(an);
 173 }
 174
 175 bool
 176 auth_name_defined(const struct auth_group *ag)
 177 {
 178         if (TAILQ_EMPTY(&ag->ag_names))
 179                 return (false);
 180         return (true);
 181 }
 182
 183 const struct auth_name *
 184 auth_name_find(const struct auth_group *ag, const char *name)
 185 {
 186         const struct auth_name *auth_name;
 187
 188         TAILQ_FOREACH(auth_name, &ag->ag_names, an_next) {
 189                 if (strcmp(auth_name->an_initator_name, name) == 0)
 190                         return (auth_name);
 191         }
 192
 193         return (NULL);
 194 }
 195
 196 const struct auth_portal *
 197 auth_portal_new(struct auth_group *ag, const char *portal)
 198 {
 199         struct auth_portal *ap;
 200
 201         ap = calloc(1, sizeof(*ap));
 202         if (ap == NULL)
 203                 log_err(1, "calloc");
 204         ap->ap_auth_group = ag;
 205         ap->ap_initator_portal = checked_strdup(portal);
 206         TAILQ_INSERT_TAIL(&ag->ag_portals, ap, ap_next);
 207         return (ap);
 208 }
 209
 210 static void
 211 auth_portal_delete(struct auth_portal *ap)
 212 {
 213         TAILQ_REMOVE(&ap->ap_auth_group->ag_portals, ap, ap_next);
 214
 215         free(ap->ap_initator_portal);
 216         free(ap);
 217 }
 218
 219 bool
 220 auth_portal_defined(const struct auth_group *ag)
 221 {
 222         if (TAILQ_EMPTY(&ag->ag_portals))
 223                 return (false);
 224         return (true);
 225 }
 226
 227 const struct auth_portal *
 228 auth_portal_find(const struct auth_group *ag, const char *portal)
 229 {
 230         const struct auth_portal *auth_portal;
 231
 232         TAILQ_FOREACH(auth_portal, &ag->ag_portals, ap_next) {
 233                 if (strcmp(auth_portal->ap_initator_portal, portal) == 0)
 234                         return (auth_portal);
 235         }
 236
 237         return (NULL);
 238 }
 239
 240 struct auth_group *
 241 auth_group_new(struct conf *conf, const char *name)
 242 {
 243         struct auth_group *ag;
 244
 245         if (name != NULL) {
 246                 ag = auth_group_find(conf, name);
 247                 if (ag != NULL) {
 248                         log_warnx("duplicated auth-group \"%s\"", name);
 249                         return (NULL);
 250                 }
 251         }
 252
 253         ag = calloc(1, sizeof(*ag));
 254         if (ag == NULL)
 255                 log_err(1, "calloc");
 256         if (name != NULL)
 257                 ag->ag_name = checked_strdup(name);
 258         TAILQ_INIT(&ag->ag_auths);
 259         TAILQ_INIT(&ag->ag_names);
 260         TAILQ_INIT(&ag->ag_portals);
 261         ag->ag_conf = conf;
 262         TAILQ_INSERT_TAIL(&conf->conf_auth_groups, ag, ag_next);
 263
 264         return (ag);
 265 }
 266
 267 void
 268 auth_group_delete(struct auth_group *ag)
 269 {
 270         struct auth *auth, *auth_tmp;
 271         struct auth_name *auth_name, *auth_name_tmp;
 272         struct auth_portal *auth_portal, *auth_portal_tmp;
 273
 274         TAILQ_REMOVE(&ag->ag_conf->conf_auth_groups, ag, ag_next);
 275
 276         TAILQ_FOREACH_SAFE(auth, &ag->ag_auths, a_next, auth_tmp)
 277                 auth_delete(auth);
 278         TAILQ_FOREACH_SAFE(auth_name, &ag->ag_names, an_next, auth_name_tmp)
 279                 auth_name_delete(auth_name);
 280         TAILQ_FOREACH_SAFE(auth_portal, &ag->ag_portals, ap_next,
 281             auth_portal_tmp)
 282                 auth_portal_delete(auth_portal);
 283         free(ag->ag_name);
 284         free(ag);
 285 }
 286
 287 struct auth_group *
 288 auth_group_find(struct conf *conf, const char *name)
 289 {
 290         struct auth_group *ag;
 291
 292         TAILQ_FOREACH(ag, &conf->conf_auth_groups, ag_next) {
 293                 if (ag->ag_name != NULL && strcmp(ag->ag_name, name) == 0)
 294                         return (ag);
 295         }
 296
 297         return (NULL);
 298 }
 299
 300 static void
 301 auth_check_secret_length(struct auth *auth)
 302 {
 303         size_t len;
 304
 305         len = strlen(auth->a_secret);
 306         if (len > 16) {
 307                 if (auth->a_auth_group->ag_name != NULL)
 308                         log_warnx("secret for user \"%s\", auth-group \"%s\", "
 309                             "is too long; it should be at most 16 characters "
 310                             "long", auth->a_user, auth->a_auth_group->ag_name);
 311                 else
 312                         log_warnx("secret for user \"%s\", target \"%s\", "
 313                             "is too long; it should be at most 16 characters "
 314                             "long", auth->a_user,
 315                             auth->a_auth_group->ag_target->t_iqn);
 316         }
 317         if (len < 12) {
 318                 if (auth->a_auth_group->ag_name != NULL)
 319                         log_warnx("secret for user \"%s\", auth-group \"%s\", "
 320                             "is too short; it should be at least 12 characters "
 321                             "long", auth->a_user,
 322                             auth->a_auth_group->ag_name);
 323                 else
 324                         log_warnx("secret for user \"%s\", target \"%s\", "
 325                             "is too short; it should be at least 16 characters "
 326                             "long", auth->a_user,
 327                             auth->a_auth_group->ag_target->t_iqn);
 328         }
 329
 330         if (auth->a_mutual_secret != NULL) {
 331                 len = strlen(auth->a_secret);
 332                 if (len > 16) {
 333                         if (auth->a_auth_group->ag_name != NULL)
 334                                 log_warnx("mutual secret for user \"%s\", "
 335                                     "auth-group \"%s\", is too long; it should "
 336                                     "be at most 16 characters long",
 337                                     auth->a_user, auth->a_auth_group->ag_name);
 338                         else
 339                                 log_warnx("mutual secret for user \"%s\", "
 340                                     "target \"%s\", is too long; it should "
 341                                     "be at most 16 characters long",
 342                                     auth->a_user,
 343                                     auth->a_auth_group->ag_target->t_iqn);
 344                 }
 345                 if (len < 12) {
 346                         if (auth->a_auth_group->ag_name != NULL)
 347                                 log_warnx("mutual secret for user \"%s\", "
 348                                     "auth-group \"%s\", is too short; it "
 349                                     "should be at least 12 characters long",
 350                                     auth->a_user, auth->a_auth_group->ag_name);
 351                         else
 352                                 log_warnx("mutual secret for user \"%s\", "
 353                                     "target \"%s\", is too short; it should be "
 354                                     "at least 16 characters long",
 355                                     auth->a_user,
 356                                     auth->a_auth_group->ag_target->t_iqn);
 357                 }
 358         }
 359 }
 360
 361 const struct auth *
 362 auth_new_chap(struct auth_group *ag, const char *user,
 363     const char *secret)
 364 {
 365         struct auth *auth;
 366
 367         if (ag->ag_type == AG_TYPE_UNKNOWN)
 368                 ag->ag_type = AG_TYPE_CHAP;
 369         if (ag->ag_type != AG_TYPE_CHAP) {
 370                 if (ag->ag_name != NULL)
 371                         log_warnx("cannot mix \"chap\" authentication with "
 372                             "other types for auth-group \"%s\"", ag->ag_name);
 373                 else
 374                         log_warnx("cannot mix \"chap\" authentication with "
 375                             "other types for target \"%s\"",
 376                             ag->ag_target->t_iqn);
 377                 return (NULL);
 378         }
 379
 380         auth = auth_new(ag);
 381         auth->a_user = checked_strdup(user);
 382         auth->a_secret = checked_strdup(secret);
 383
 384         auth_check_secret_length(auth);
 385
 386         return (auth);
 387 }
 388
 389 const struct auth *
 390 auth_new_chap_mutual(struct auth_group *ag, const char *user,
 391     const char *secret, const char *user2, const char *secret2)
 392 {
 393         struct auth *auth;
 394
 395         if (ag->ag_type == AG_TYPE_UNKNOWN)
 396                 ag->ag_type = AG_TYPE_CHAP_MUTUAL;
 397         if (ag->ag_type != AG_TYPE_CHAP_MUTUAL) {
 398                 if (ag->ag_name != NULL)
 399                         log_warnx("cannot mix \"chap-mutual\" authentication "
 400                             "with other types for auth-group \"%s\"",
 401                             ag->ag_name);
 402                 else
 403                         log_warnx("cannot mix \"chap-mutual\" authentication "
 404                             "with other types for target \"%s\"",
 405                             ag->ag_target->t_iqn);
 406                 return (NULL);
 407         }
 408
 409         auth = auth_new(ag);
 410         auth->a_user = checked_strdup(user);
 411         auth->a_secret = checked_strdup(secret);
 412         auth->a_mutual_user = checked_strdup(user2);
 413         auth->a_mutual_secret = checked_strdup(secret2);
 414
 415         auth_check_secret_length(auth);
 416
 417         return (auth);
 418 }
 419
 420 static struct portal *
 421 portal_new(struct portal_group *pg)
 422 {
 423         struct portal *portal;
 424
 425         portal = calloc(1, sizeof(*portal));
 426         if (portal == NULL)
 427                 log_err(1, "calloc");
 428         TAILQ_INIT(&portal->p_targets);
 429         portal->p_portal_group = pg;
 430         TAILQ_INSERT_TAIL(&pg->pg_portals, portal, p_next);
 431         return (portal);
 432 }
 433
 434 static void
 435 portal_delete(struct portal *portal)
 436 {
 437         TAILQ_REMOVE(&portal->p_portal_group->pg_portals, portal, p_next);
 438         freeaddrinfo(portal->p_ai);
 439         free(portal->p_listen);
 440         free(portal);
 441 }
 442
 443 struct portal_group *
 444 portal_group_new(struct conf *conf, const char *name)
 445 {
 446         struct portal_group *pg;
 447
 448         pg = portal_group_find(conf, name);
 449         if (pg != NULL) {
 450                 log_warnx("duplicated portal-group \"%s\"", name);
 451                 return (NULL);
 452         }
 453
 454         pg = calloc(1, sizeof(*pg));
 455         if (pg == NULL)
 456                 log_err(1, "calloc");
 457         pg->pg_name = checked_strdup(name);
 458         TAILQ_INIT(&pg->pg_portals);
 459         pg->pg_conf = conf;
 460         conf->conf_last_portal_group_tag++;
 461         pg->pg_tag = conf->conf_last_portal_group_tag;
 462         TAILQ_INSERT_TAIL(&conf->conf_portal_groups, pg, pg_next);
 463
 464         return (pg);
 465 }
 466
 467 void
 468 portal_group_delete(struct portal_group *pg)
 469 {
 470         struct portal *portal, *tmp;
 471
 472         TAILQ_REMOVE(&pg->pg_conf->conf_portal_groups, pg, pg_next);
 473
 474         TAILQ_FOREACH_SAFE(portal, &pg->pg_portals, p_next, tmp)
 475                 portal_delete(portal);
 476         free(pg->pg_name);
 477         free(pg);
 478 }
 479
 480 struct portal_group *
 481 portal_group_find(struct conf *conf, const char *name)
 482 {
 483         struct portal_group *pg;
 484
 485         TAILQ_FOREACH(pg, &conf->conf_portal_groups, pg_next) {
 486                 if (strcmp(pg->pg_name, name) == 0)
 487                         return (pg);
 488         }
 489
 490         return (NULL);
 491 }
 492
 493 int
 494 portal_group_add_listen(struct portal_group *pg, const char *value, bool iser)
 495 {
 496         struct addrinfo hints;
 497         struct portal *portal;
 498         char *addr, *ch, *arg;
 499         const char *port;
 500         int error, colons = 0;
 501
 502 #ifndef ICL_KERNEL_PROXY
 503         if (iser) {
 504                 log_warnx("ctld(8) compiled without ICL_KERNEL_PROXY "
 505                     "does not support iSER protocol");
 506                 return (-1);
 507         }
 508 #endif
 509
 510         portal = portal_new(pg);
 511         portal->p_listen = checked_strdup(value);
 512         portal->p_iser = iser;
 513
 514         arg = portal->p_listen;
 515         if (arg[0] == '\0') {
 516                 log_warnx("empty listen address");
 517                 free(portal->p_listen);
 518                 free(portal);
 519                 return (1);
 520         }
 521         if (arg[0] == '[') {
 522                 /*
 523                  * IPv6 address in square brackets, perhaps with port.
 524                  */
 525                 arg++;
 526                 addr = strsep(&arg, "]");
 527                 if (arg == NULL) {
 528                         log_warnx("invalid listen address %s",
 529                             portal->p_listen);
 530                         free(portal->p_listen);
 531                         free(portal);
 532                         return (1);
 533                 }
 534                 if (arg[0] == '\0') {
 535                         port = "3260";
 536                 } else if (arg[0] == ':') {
 537                         port = arg + 1;
 538                 } else {
 539                         log_warnx("invalid listen address %s",
 540                             portal->p_listen);
 541                         free(portal->p_listen);
 542                         free(portal);
 543                         return (1);
 544                 }
 545         } else {
 546                 /*
 547                  * Either IPv6 address without brackets - and without
 548                  * a port - or IPv4 address.  Just count the colons.
 549                  */
 550                 for (ch = arg; *ch != '\0'; ch++) {
 551                         if (*ch == ':')
 552                                 colons++;
 553                 }
 554                 if (colons > 1) {
 555                         addr = arg;
 556                         port = "3260";
 557                 } else {
 558                         addr = strsep(&arg, ":");
 559                         if (arg == NULL)
 560                                 port = "3260";
 561                         else
 562                                 port = arg;
 563                 }
 564         }
 565
 566         memset(&hints, 0, sizeof(hints));
 567         hints.ai_family = PF_UNSPEC;
 568         hints.ai_socktype = SOCK_STREAM;
 569         hints.ai_flags = AI_PASSIVE;
 570
 571         error = getaddrinfo(addr, port, &hints, &portal->p_ai);
 572         if (error != 0) {
 573                 log_warnx("getaddrinfo for %s failed: %s",
 574                     portal->p_listen, gai_strerror(error));
 575                 free(portal->p_listen);
 576                 free(portal);
 577                 return (1);
 578         }
 579
 580         /*
 581          * XXX: getaddrinfo(3) may return multiple addresses; we should turn
 582          *      those into multiple portals.
 583          */
 584
 585         return (0);
 586 }
 587
 588 static bool
 589 valid_hex(const char ch)
 590 {
 591         switch (ch) {
 592         case '0':
 593         case '1':
 594         case '2':
 595         case '3':
 596         case '4':
 597         case '5':
 598         case '6':
 599         case '7':
 600         case '8':
 601         case '9':
 602         case 'a':
 603         case 'A':
 604         case 'b':
 605         case 'B':
 606         case 'c':
 607         case 'C':
 608         case 'd':
 609         case 'D':
 610         case 'e':
 611         case 'E':
 612         case 'f':
 613         case 'F':
 614                 return (true);
 615         default:
 616                 return (false);
 617         }
 618 }
 619
 620 bool
 621 valid_iscsi_name(const char *name)
 622 {
 623         int i;
 624
 625         if (strlen(name) >= MAX_NAME_LEN) {
 626                 log_warnx("overlong name for target \"%s\"; max length allowed "
 627                     "by iSCSI specification is %d characters",
 628                     name, MAX_NAME_LEN);
 629                 return (false);
 630         }
 631
 632         /*
 633          * In the cases below, we don't return an error, just in case the admin
 634          * was right, and we're wrong.
 635          */
 636         if (strncasecmp(name, "iqn.", strlen("iqn.")) == 0) {
 637                 for (i = strlen("iqn."); name[i] != '\0'; i++) {
 638                         /*
 639                          * XXX: We should verify UTF-8 normalisation, as defined
 640                          *      by 3.2.6.2: iSCSI Name Encoding.
 641                          */
 642                         if (isalnum(name[i]))
 643                                 continue;
 644                         if (name[i] == '-' || name[i] == '.' || name[i] == ':')
 645                                 continue;
 646                         log_warnx("invalid character \"%c\" in target name "
 647                             "\"%s\"; allowed characters are letters, digits, "
 648                             "'-', '.', and ':'", name[i], name);
 649                         break;
 650                 }
 651                 /*
 652                  * XXX: Check more stuff: valid date and a valid reversed domain.
 653                  */
 654         } else if (strncasecmp(name, "eui.", strlen("eui.")) == 0) {
 655                 if (strlen(name) != strlen("eui.") + 16)
 656                         log_warnx("invalid target name \"%s\"; the \"eui.\" "
 657                             "should be followed by exactly 16 hexadecimal "
 658                             "digits", name);
 659                 for (i = strlen("eui."); name[i] != '\0'; i++) {
 660                         if (!valid_hex(name[i])) {
 661                                 log_warnx("invalid character \"%c\" in target "
 662                                     "name \"%s\"; allowed characters are 1-9 "
 663                                     "and A-F", name[i], name);
 664                                 break;
 665                         }
 666                 }
 667         } else if (strncasecmp(name, "naa.", strlen("naa.")) == 0) {
 668                 if (strlen(name) > strlen("naa.") + 32)
 669                         log_warnx("invalid target name \"%s\"; the \"naa.\" "
 670                             "should be followed by at most 32 hexadecimal "
 671                             "digits", name);
 672                 for (i = strlen("naa."); name[i] != '\0'; i++) {
 673                         if (!valid_hex(name[i])) {
 674                                 log_warnx("invalid character \"%c\" in target "
 675                                     "name \"%s\"; allowed characters are 1-9 "
 676                                     "and A-F", name[i], name);
 677                                 break;
 678                         }
 679                 }
 680         } else {
 681                 log_warnx("invalid target name \"%s\"; should start with "
 682                     "either \".iqn\", \"eui.\", or \"naa.\"",
 683                     name);
 684         }
 685         return (true);
 686 }
 687
 688 struct target *
 689 target_new(struct conf *conf, const char *iqn)
 690 {
 691         struct target *targ;
 692         int i, len;
 693
 694         targ = target_find(conf, iqn);
 695         if (targ != NULL) {
 696                 log_warnx("duplicated target \"%s\"", iqn);
 697                 return (NULL);
 698         }
 699         if (valid_iscsi_name(iqn) == false) {
 700                 log_warnx("target name \"%s\" is invalid", iqn);
 701                 return (NULL);
 702         }
 703         targ = calloc(1, sizeof(*targ));
 704         if (targ == NULL)
 705                 log_err(1, "calloc");
 706         targ->t_iqn = checked_strdup(iqn);
 707
 708         /*
 709          * RFC 3722 requires us to normalize the name to lowercase.
 710          */
 711         len = strlen(iqn);
 712         for (i = 0; i < len; i++)
 713                 targ->t_iqn[i] = tolower(targ->t_iqn[i]);
 714
 715         TAILQ_INIT(&targ->t_luns);
 716         targ->t_conf = conf;
 717         TAILQ_INSERT_TAIL(&conf->conf_targets, targ, t_next);
 718
 719         return (targ);
 720 }
 721
 722 void
 723 target_delete(struct target *targ)
 724 {
 725         struct lun *lun, *tmp;
 726
 727         TAILQ_REMOVE(&targ->t_conf->conf_targets, targ, t_next);
 728
 729         TAILQ_FOREACH_SAFE(lun, &targ->t_luns, l_next, tmp)
 730                 lun_delete(lun);
 731         free(targ->t_iqn);
 732         free(targ);
 733 }
 734
 735 struct target *
 736 target_find(struct conf *conf, const char *iqn)
 737 {
 738         struct target *targ;
 739
 740         TAILQ_FOREACH(targ, &conf->conf_targets, t_next) {
 741                 if (strcasecmp(targ->t_iqn, iqn) == 0)
 742                         return (targ);
 743         }
 744
 745         return (NULL);
 746 }
 747
 748 struct lun *
 749 lun_new(struct target *targ, int lun_id)
 750 {
 751         struct lun *lun;
 752
 753         lun = lun_find(targ, lun_id);
 754         if (lun != NULL) {
 755                 log_warnx("duplicated lun %d for target \"%s\"",
 756                     lun_id, targ->t_iqn);
 757                 return (NULL);
 758         }
 759
 760         lun = calloc(1, sizeof(*lun));
 761         if (lun == NULL)
 762                 log_err(1, "calloc");
 763         lun->l_lun = lun_id;
 764         TAILQ_INIT(&lun->l_options);
 765         lun->l_target = targ;
 766         TAILQ_INSERT_TAIL(&targ->t_luns, lun, l_next);
 767
 768         return (lun);
 769 }
 770
 771 void
 772 lun_delete(struct lun *lun)
 773 {
 774         struct lun_option *lo, *tmp;
 775
 776         TAILQ_REMOVE(&lun->l_target->t_luns, lun, l_next);
 777
 778         TAILQ_FOREACH_SAFE(lo, &lun->l_options, lo_next, tmp)
 779                 lun_option_delete(lo);
 780         free(lun->l_backend);
 781         free(lun->l_device_id);
 782         free(lun->l_path);
 783         free(lun->l_serial);
 784         free(lun);
 785 }
 786
 787 struct lun *
 788 lun_find(struct target *targ, int lun_id)
 789 {
 790         struct lun *lun;
 791
 792         TAILQ_FOREACH(lun, &targ->t_luns, l_next) {
 793                 if (lun->l_lun == lun_id)
 794                         return (lun);
 795         }
 796
 797         return (NULL);
 798 }
 799
 800 void
 801 lun_set_backend(struct lun *lun, const char *value)
 802 {
 803         free(lun->l_backend);
 804         lun->l_backend = checked_strdup(value);
 805 }
 806
 807 void
 808 lun_set_blocksize(struct lun *lun, size_t value)
 809 {
 810
 811         lun->l_blocksize = value;
 812 }
 813
 814 void
 815 lun_set_device_id(struct lun *lun, const char *value)
 816 {
 817         free(lun->l_device_id);
 818         lun->l_device_id = checked_strdup(value);
 819 }
 820
 821 void
 822 lun_set_path(struct lun *lun, const char *value)
 823 {
 824         free(lun->l_path);
 825         lun->l_path = checked_strdup(value);
 826 }
 827
 828 void
 829 lun_set_serial(struct lun *lun, const char *value)
 830 {
 831         free(lun->l_serial);
 832         lun->l_serial = checked_strdup(value);
 833 }
 834
 835 void
 836 lun_set_size(struct lun *lun, size_t value)
 837 {
 838
 839         lun->l_size = value;
 840 }
 841
 842 void
 843 lun_set_ctl_lun(struct lun *lun, uint32_t value)
 844 {
 845
 846         lun->l_ctl_lun = value;
 847 }
 848
 849 struct lun_option *
 850 lun_option_new(struct lun *lun, const char *name, const char *value)
 851 {
 852         struct lun_option *lo;
 853
 854         lo = lun_option_find(lun, name);
 855         if (lo != NULL) {
 856                 log_warnx("duplicated lun option %s for lun %d, target \"%s\"",
 857                     name, lun->l_lun, lun->l_target->t_iqn);
 858                 return (NULL);
 859         }
 860
 861         lo = calloc(1, sizeof(*lo));
 862         if (lo == NULL)
 863                 log_err(1, "calloc");
 864         lo->lo_name = checked_strdup(name);
 865         lo->lo_value = checked_strdup(value);
 866         lo->lo_lun = lun;
 867         TAILQ_INSERT_TAIL(&lun->l_options, lo, lo_next);
 868
 869         return (lo);
 870 }
 871
 872 void
 873 lun_option_delete(struct lun_option *lo)
 874 {
 875
 876         TAILQ_REMOVE(&lo->lo_lun->l_options, lo, lo_next);
 877
 878         free(lo->lo_name);
 879         free(lo->lo_value);
 880         free(lo);
 881 }
 882
 883 struct lun_option *
 884 lun_option_find(struct lun *lun, const char *name)
 885 {
 886         struct lun_option *lo;
 887
 888         TAILQ_FOREACH(lo, &lun->l_options, lo_next) {
 889                 if (strcmp(lo->lo_name, name) == 0)
 890                         return (lo);
 891         }
 892
 893         return (NULL);
 894 }
 895
 896 void
 897 lun_option_set(struct lun_option *lo, const char *value)
 898 {
 899
 900         free(lo->lo_value);
 901         lo->lo_value = checked_strdup(value);
 902 }
 903
 904 static struct connection *
 905 connection_new(struct portal *portal, int fd, const char *host)
 906 {
 907         struct connection *conn;
 908
 909         conn = calloc(1, sizeof(*conn));
 910         if (conn == NULL)
 911                 log_err(1, "calloc");
 912         conn->conn_portal = portal;
 913         conn->conn_socket = fd;
 914         conn->conn_initiator_addr = checked_strdup(host);
 915
 916         /*
 917          * Default values, from RFC 3720, section 12.
 918          */
 919         conn->conn_max_data_segment_length = 8192;
 920         conn->conn_max_burst_length = 262144;
 921         conn->conn_immediate_data = true;
 922
 923         return (conn);
 924 }
 925
 926 #if 0
 927 static void
 928 conf_print(struct conf *conf)
 929 {
 930         struct auth_group *ag;
 931         struct auth *auth;
 932         struct auth_name *auth_name;
 933         struct auth_portal *auth_portal;
 934         struct portal_group *pg;
 935         struct portal *portal;
 936         struct target *targ;
 937         struct lun *lun;
 938         struct lun_option *lo;
 939
 940         TAILQ_FOREACH(ag, &conf->conf_auth_groups, ag_next) {
 941                 fprintf(stderr, "auth-group %s {\n", ag->ag_name);
 942                 TAILQ_FOREACH(auth, &ag->ag_auths, a_next)
 943                         fprintf(stderr, "\t chap-mutual %s %s %s %s\n",
 944                             auth->a_user, auth->a_secret,
 945                             auth->a_mutual_user, auth->a_mutual_secret);
 946                 TAILQ_FOREACH(auth_name, &ag->ag_names, an_next)
 947                         fprintf(stderr, "\t initiator-name %s\n",
 948                             auth_name->an_initator_name);
 949                 TAILQ_FOREACH(auth_portal, &ag->ag_portals, an_next)
 950                         fprintf(stderr, "\t initiator-portal %s\n",
 951                             auth_portal->an_initator_portal);
 952                 fprintf(stderr, "}\n");
 953         }
 954         TAILQ_FOREACH(pg, &conf->conf_portal_groups, pg_next) {
 955                 fprintf(stderr, "portal-group %s {\n", pg->pg_name);
 956                 TAILQ_FOREACH(portal, &pg->pg_portals, p_next)
 957                         fprintf(stderr, "\t listen %s\n", portal->p_listen);
 958                 fprintf(stderr, "}\n");
 959         }
 960         TAILQ_FOREACH(targ, &conf->conf_targets, t_next) {
 961                 fprintf(stderr, "target %s {\n", targ->t_iqn);
 962                 if (targ->t_alias != NULL)
 963                         fprintf(stderr, "\t alias %s\n", targ->t_alias);
 964                 TAILQ_FOREACH(lun, &targ->t_luns, l_next) {
 965                         fprintf(stderr, "\tlun %d {\n", lun->l_lun);
 966                         fprintf(stderr, "\t\tpath %s\n", lun->l_path);
 967                         TAILQ_FOREACH(lo, &lun->l_options, lo_next)
 968                                 fprintf(stderr, "\t\toption %s %s\n",
 969                                     lo->lo_name, lo->lo_value);
 970                         fprintf(stderr, "\t}\n");
 971                 }
 972                 fprintf(stderr, "}\n");
 973         }
 974 }
 975 #endif
 976
 977 static int
 978 conf_verify_lun(struct lun *lun)
 979 {
 980         const struct lun *lun2;
 981         const struct target *targ2;
 982
 983         if (lun->l_backend == NULL)
 984                 lun_set_backend(lun, "block");
 985         if (strcmp(lun->l_backend, "block") == 0) {
 986                 if (lun->l_path == NULL) {
 987                         log_warnx("missing path for lun %d, target \"%s\"",
 988                             lun->l_lun, lun->l_target->t_iqn);
 989                         return (1);
 990                 }
 991         } else if (strcmp(lun->l_backend, "ramdisk") == 0) {
 992                 if (lun->l_size == 0) {
 993                         log_warnx("missing size for ramdisk-backed lun %d, "
 994                             "target \"%s\"", lun->l_lun, lun->l_target->t_iqn);
 995                         return (1);
 996                 }
 997                 if (lun->l_path != NULL) {
 998                         log_warnx("path must not be specified "
 999                             "for ramdisk-backed lun %d, target \"%s\"",
1000                             lun->l_lun, lun->l_target->t_iqn);
1001                         return (1);
1002                 }
1003         }
1004         if (lun->l_lun < 0 || lun->l_lun > 255) {
1005                 log_warnx("invalid lun number for lun %d, target \"%s\"; "
1006                     "must be between 0 and 255", lun->l_lun,
1007                     lun->l_target->t_iqn);
1008                 return (1);
1009         }
1010         if (lun->l_blocksize == 0) {
1011                 lun_set_blocksize(lun, DEFAULT_BLOCKSIZE);
1012         } else if (lun->l_blocksize < 0) {
1013                 log_warnx("invalid blocksize for lun %d, target \"%s\"; "
1014                     "must be larger than 0", lun->l_lun, lun->l_target->t_iqn);
1015                 return (1);
1016         }
1017         if (lun->l_size != 0 && lun->l_size % lun->l_blocksize != 0) {
1018                 log_warnx("invalid size for lun %d, target \"%s\"; "
1019                     "must be multiple of blocksize", lun->l_lun,
1020                     lun->l_target->t_iqn);
1021                 return (1);
1022         }
1023         TAILQ_FOREACH(targ2, &lun->l_target->t_conf->conf_targets, t_next) {
1024                 TAILQ_FOREACH(lun2, &targ2->t_luns, l_next) {
1025                         if (lun == lun2)
1026                                 continue;
1027                         if (lun->l_path != NULL && lun2->l_path != NULL &&
1028                             strcmp(lun->l_path, lun2->l_path) == 0) {
1029                                 log_debugx("WARNING: path \"%s\" duplicated "
1030                                     "between lun %d, target \"%s\", and "
1031                                     "lun %d, target \"%s\"", lun->l_path,
1032                                     lun->l_lun, lun->l_target->t_iqn,
1033                                     lun2->l_lun, lun2->l_target->t_iqn);
1034                         }
1035                 }
1036         }
1037
1038         return (0);
1039 }
1040
1041 int
1042 conf_verify(struct conf *conf)
1043 {
1044         struct auth_group *ag;
1045         struct portal_group *pg;
1046         struct target *targ;
1047         struct lun *lun;
1048         bool found_lun0;
1049         int error;
1050
1051         if (conf->conf_pidfile_path == NULL)
1052                 conf->conf_pidfile_path = checked_strdup(DEFAULT_PIDFILE);
1053
1054         TAILQ_FOREACH(targ, &conf->conf_targets, t_next) {
1055                 if (targ->t_auth_group == NULL) {
1056                         log_warnx("missing authentication for target \"%s\"; "
1057                             "must specify either \"auth-group\", \"chap\", "
1058                             "or \"chap-mutual\"", targ->t_iqn);
1059                         return (1);
1060                 }
1061                 if (targ->t_portal_group == NULL) {
1062                         targ->t_portal_group = portal_group_find(conf,
1063                             "default");
1064                         assert(targ->t_portal_group != NULL);
1065                 }
1066                 found_lun0 = false;
1067                 TAILQ_FOREACH(lun, &targ->t_luns, l_next) {
1068                         error = conf_verify_lun(lun);
1069                         if (error != 0)
1070                                 return (error);
1071                         if (lun->l_lun == 0)
1072                                 found_lun0 = true;
1073                 }
1074                 if (!found_lun0) {
1075                         log_warnx("mandatory LUN 0 not configured "
1076                             "for target \"%s\"", targ->t_iqn);
1077                         return (1);
1078                 }
1079         }
1080         TAILQ_FOREACH(pg, &conf->conf_portal_groups, pg_next) {
1081                 assert(pg->pg_name != NULL);
1082                 if (pg->pg_discovery_auth_group == NULL) {
1083                         pg->pg_discovery_auth_group =
1084                             auth_group_find(conf, "no-access");
1085                         assert(pg->pg_discovery_auth_group != NULL);
1086                 }
1087
1088                 TAILQ_FOREACH(targ, &conf->conf_targets, t_next) {
1089                         if (targ->t_portal_group == pg)
1090                                 break;
1091                 }
1092                 if (targ == NULL) {
1093                         if (strcmp(pg->pg_name, "default") != 0)
1094                                 log_warnx("portal-group \"%s\" not assigned "
1095                                     "to any target", pg->pg_name);
1096                         pg->pg_unassigned = true;
1097                 } else
1098                         pg->pg_unassigned = false;
1099         }
1100         TAILQ_FOREACH(ag, &conf->conf_auth_groups, ag_next) {
1101                 if (ag->ag_name == NULL)
1102                         assert(ag->ag_target != NULL);
1103                 else
1104                         assert(ag->ag_target == NULL);
1105
1106                 TAILQ_FOREACH(targ, &conf->conf_targets, t_next) {
1107                         if (targ->t_auth_group == ag)
1108                                 break;
1109                 }
1110                 if (targ == NULL && ag->ag_name != NULL &&
1111                     strcmp(ag->ag_name, "no-authentication") != 0 &&
1112                     strcmp(ag->ag_name, "no-access") != 0) {
1113                         log_warnx("auth-group \"%s\" not assigned "
1114                             "to any target", ag->ag_name);
1115                 }
1116         }
1117
1118         return (0);
1119 }
1120
1121 static int
1122 conf_apply(struct conf *oldconf, struct conf *newconf)
1123 {
1124         struct target *oldtarg, *newtarg, *tmptarg;
1125         struct lun *oldlun, *newlun, *tmplun;
1126         struct portal_group *oldpg, *newpg;
1127         struct portal *oldp, *newp;
1128         pid_t otherpid;
1129         int changed, cumulated_error = 0, error;
1130 #ifndef ICL_KERNEL_PROXY
1131         int one = 1;
1132 #endif
1133
1134         if (oldconf->conf_debug != newconf->conf_debug) {
1135                 log_debugx("changing debug level to %d", newconf->conf_debug);
1136                 log_init(newconf->conf_debug);
1137         }
1138
1139         if (oldconf->conf_pidfh != NULL) {
1140                 assert(oldconf->conf_pidfile_path != NULL);
1141                 if (newconf->conf_pidfile_path != NULL &&
1142                     strcmp(oldconf->conf_pidfile_path,
1143                     newconf->conf_pidfile_path) == 0) {
1144                         newconf->conf_pidfh = oldconf->conf_pidfh;
1145                         oldconf->conf_pidfh = NULL;
1146                 } else {
1147                         log_debugx("removing pidfile %s",
1148                             oldconf->conf_pidfile_path);
1149                         pidfile_remove(oldconf->conf_pidfh);
1150                         oldconf->conf_pidfh = NULL;
1151                 }
1152         }
1153
1154         if (newconf->conf_pidfh == NULL && newconf->conf_pidfile_path != NULL) {
1155                 log_debugx("opening pidfile %s", newconf->conf_pidfile_path);
1156                 newconf->conf_pidfh =
1157                     pidfile_open(newconf->conf_pidfile_path, 0600, &otherpid);
1158                 if (newconf->conf_pidfh == NULL) {
1159                         if (errno == EEXIST)
1160                                 log_errx(1, "daemon already running, pid: %jd.",
1161                                     (intmax_t)otherpid);
1162                         log_err(1, "cannot open or create pidfile \"%s\"",
1163                             newconf->conf_pidfile_path);
1164                 }
1165         }
1166
1167         TAILQ_FOREACH_SAFE(oldtarg, &oldconf->conf_targets, t_next, tmptarg) {
1168                 /*
1169                  * First, remove any targets present in the old configuration
1170                  * and missing in the new one.
1171                  */
1172                 newtarg = target_find(newconf, oldtarg->t_iqn);
1173                 if (newtarg == NULL) {
1174                         TAILQ_FOREACH_SAFE(oldlun, &oldtarg->t_luns, l_next,
1175                             tmplun) {
1176                                 log_debugx("target %s not found in new "
1177                                     "configuration; removing its lun %d, "
1178                                     "backed by CTL lun %d",
1179                                     oldtarg->t_iqn, oldlun->l_lun,
1180                                     oldlun->l_ctl_lun);
1181                                 error = kernel_lun_remove(oldlun);
1182                                 if (error != 0) {
1183                                         log_warnx("failed to remove lun %d, "
1184                                             "target %s, CTL lun %d",
1185                                             oldlun->l_lun, oldtarg->t_iqn,
1186                                             oldlun->l_ctl_lun);
1187                                         cumulated_error++;
1188                                 }
1189                                 lun_delete(oldlun);
1190                         }
1191                         target_delete(oldtarg);
1192                         continue;
1193                 }
1194
1195                 /*
1196                  * Second, remove any LUNs present in the old target
1197                  * and missing in the new one.
1198                  */
1199                 TAILQ_FOREACH_SAFE(oldlun, &oldtarg->t_luns, l_next, tmplun) {
1200                         newlun = lun_find(newtarg, oldlun->l_lun);
1201                         if (newlun == NULL) {
1202                                 log_debugx("lun %d, target %s, CTL lun %d "
1203                                     "not found in new configuration; "
1204                                     "removing", oldlun->l_lun, oldtarg->t_iqn,
1205                                     oldlun->l_ctl_lun);
1206                                 error = kernel_lun_remove(oldlun);
1207                                 if (error != 0) {
1208                                         log_warnx("failed to remove lun %d, "
1209                                             "target %s, CTL lun %d",
1210                                             oldlun->l_lun, oldtarg->t_iqn,
1211                                             oldlun->l_ctl_lun);
1212                                         cumulated_error++;
1213                                 }
1214                                 lun_delete(oldlun);
1215                                 continue;
1216                         }
1217
1218                         /*
1219                          * Also remove the LUNs changed by more than size.
1220                          */
1221                         changed = 0;
1222                         assert(oldlun->l_backend != NULL);
1223                         assert(newlun->l_backend != NULL);
1224                         if (strcmp(newlun->l_backend, oldlun->l_backend) != 0) {
1225                                 log_debugx("backend for lun %d, target %s, "
1226                                     "CTL lun %d changed; removing",
1227                                     oldlun->l_lun, oldtarg->t_iqn,
1228                                     oldlun->l_ctl_lun);
1229                                 changed = 1;
1230                         }
1231                         if (oldlun->l_blocksize != newlun->l_blocksize) {
1232                                 log_debugx("blocksize for lun %d, target %s, "
1233                                     "CTL lun %d changed; removing",
1234                                     oldlun->l_lun, oldtarg->t_iqn,
1235                                     oldlun->l_ctl_lun);
1236                                 changed = 1;
1237                         }
1238                         if (newlun->l_device_id != NULL &&
1239                             (oldlun->l_device_id == NULL ||
1240                              strcmp(oldlun->l_device_id, newlun->l_device_id) !=
1241                              0)) {
1242                                 log_debugx("device-id for lun %d, target %s, "
1243                                     "CTL lun %d changed; removing",
1244                                     oldlun->l_lun, oldtarg->t_iqn,
1245                                     oldlun->l_ctl_lun);
1246                                 changed = 1;
1247                         }
1248                         if (newlun->l_path != NULL &&
1249                             (oldlun->l_path == NULL ||
1250                              strcmp(oldlun->l_path, newlun->l_path) != 0)) {
1251                                 log_debugx("path for lun %d, target %s, "
1252                                     "CTL lun %d, changed; removing",
1253                                     oldlun->l_lun, oldtarg->t_iqn,
1254                                     oldlun->l_ctl_lun);
1255                                 changed = 1;
1256                         }
1257                         if (newlun->l_serial != NULL &&
1258                             (oldlun->l_serial == NULL ||
1259                              strcmp(oldlun->l_serial, newlun->l_serial) != 0)) {
1260                                 log_debugx("serial for lun %d, target %s, "
1261                                     "CTL lun %d changed; removing",
1262                                     oldlun->l_lun, oldtarg->t_iqn,
1263                                     oldlun->l_ctl_lun);
1264                                 changed = 1;
1265                         }
1266                         if (changed) {
1267                                 error = kernel_lun_remove(oldlun);
1268                                 if (error != 0) {
1269                                         log_warnx("failed to remove lun %d, "
1270                                             "target %s, CTL lun %d",
1271                                             oldlun->l_lun, oldtarg->t_iqn,
1272                                             oldlun->l_ctl_lun);
1273                                         cumulated_error++;
1274                                 }
1275                                 lun_delete(oldlun);
1276                                 continue;
1277                         }
1278
1279                         lun_set_ctl_lun(newlun, oldlun->l_ctl_lun);
1280                 }
1281         }
1282
1283         /*
1284          * Now add new targets or modify existing ones.
1285          */
1286         TAILQ_FOREACH(newtarg, &newconf->conf_targets, t_next) {
1287                 oldtarg = target_find(oldconf, newtarg->t_iqn);
1288
1289                 TAILQ_FOREACH(newlun, &newtarg->t_luns, l_next) {
1290                         if (oldtarg != NULL) {
1291                                 oldlun = lun_find(oldtarg, newlun->l_lun);
1292                                 if (oldlun != NULL) {
1293                                         if (newlun->l_size != oldlun->l_size) {
1294                                                 log_debugx("resizing lun %d, "
1295                                                     "target %s, CTL lun %d",
1296                                                     newlun->l_lun,
1297                                                     newtarg->t_iqn,
1298                                                     newlun->l_ctl_lun);
1299                                                 error =
1300                                                     kernel_lun_resize(newlun);
1301                                                 if (error != 0) {
1302                                                         log_warnx("failed to "
1303                                                             "resize lun %d, "
1304                                                             "target %s, "
1305                                                             "CTL lun %d",
1306                                                             newlun->l_lun,
1307                                                             newtarg->t_iqn,
1308                                                             newlun->l_lun);
1309                                                         cumulated_error++;
1310                                                 }
1311                                         }
1312                                         continue;
1313                                 }
1314                         }
1315                         log_debugx("adding lun %d, target %s",
1316                             newlun->l_lun, newtarg->t_iqn);
1317                         error = kernel_lun_add(newlun);
1318                         if (error != 0) {
1319                                 log_warnx("failed to add lun %d, target %s",
1320                                     newlun->l_lun, newtarg->t_iqn);
1321                                 cumulated_error++;
1322                         }
1323                 }
1324         }
1325
1326         /*
1327          * Go through the new portals, opening the sockets as neccessary.
1328          */
1329         TAILQ_FOREACH(newpg, &newconf->conf_portal_groups, pg_next) {
1330                 if (newpg->pg_unassigned) {
1331                         log_debugx("not listening on portal-group \"%s\", "
1332                             "not assigned to any target",
1333                             newpg->pg_name);
1334                         continue;
1335                 }
1336                 TAILQ_FOREACH(newp, &newpg->pg_portals, p_next) {
1337                         /*
1338                          * Try to find already open portal and reuse
1339                          * the listening socket.  We don't care about
1340                          * what portal or portal group that was, what
1341                          * matters is the listening address.
1342                          */
1343                         TAILQ_FOREACH(oldpg, &oldconf->conf_portal_groups,
1344                             pg_next) {
1345                                 TAILQ_FOREACH(oldp, &oldpg->pg_portals,
1346                                     p_next) {
1347                                         if (strcmp(newp->p_listen,
1348                                             oldp->p_listen) == 0 &&
1349                                             oldp->p_socket > 0) {
1350                                                 newp->p_socket =
1351                                                     oldp->p_socket;
1352                                                 oldp->p_socket = 0;
1353                                                 break;
1354                                         }
1355                                 }
1356                         }
1357                         if (newp->p_socket > 0) {
1358                                 /*
1359                                  * We're done with this portal.
1360                                  */
1361                                 continue;
1362                         }
1363
1364 #ifdef ICL_KERNEL_PROXY
1365                         log_debugx("listening on %s, portal-group \"%s\" using ICL proxy",
1366                             newp->p_listen, newpg->pg_name);
1367                         kernel_listen(newp->p_ai, newp->p_iser);
1368 #else
1369                         assert(newp->p_iser == false);
1370
1371                         log_debugx("listening on %s, portal-group \"%s\"",
1372                             newp->p_listen, newpg->pg_name);
1373                         newp->p_socket = socket(newp->p_ai->ai_family,
1374                             newp->p_ai->ai_socktype,
1375                             newp->p_ai->ai_protocol);
1376                         if (newp->p_socket < 0) {
1377                                 log_warn("socket(2) failed for %s",
1378                                     newp->p_listen);
1379                                 cumulated_error++;
1380                                 continue;
1381                         }
1382                         error = setsockopt(newp->p_socket, SOL_SOCKET,
1383                             SO_REUSEADDR, &one, sizeof(one));
1384                         if (error != 0) {
1385                                 log_warn("setsockopt(SO_REUSEADDR) failed "
1386                                     "for %s", newp->p_listen);
1387                                 close(newp->p_socket);
1388                                 newp->p_socket = 0;
1389                                 cumulated_error++;
1390                                 continue;
1391                         }
1392                         error = bind(newp->p_socket, newp->p_ai->ai_addr,
1393                             newp->p_ai->ai_addrlen);
1394                         if (error != 0) {
1395                                 log_warn("bind(2) failed for %s",
1396                                     newp->p_listen);
1397                                 close(newp->p_socket);
1398                                 newp->p_socket = 0;
1399                                 cumulated_error++;
1400                                 continue;
1401                         }
1402                         error = listen(newp->p_socket, -1);
1403                         if (error != 0) {
1404                                 log_warn("listen(2) failed for %s",
1405                                     newp->p_listen);
1406                                 close(newp->p_socket);
1407                                 newp->p_socket = 0;
1408                                 cumulated_error++;
1409                                 continue;
1410                         }
1411 #endif /* !ICL_KERNEL_PROXY */
1412                 }
1413         }
1414
1415         /*
1416          * Go through the no longer used sockets, closing them.
1417          */
1418         TAILQ_FOREACH(oldpg, &oldconf->conf_portal_groups, pg_next) {
1419                 TAILQ_FOREACH(oldp, &oldpg->pg_portals, p_next) {
1420                         if (oldp->p_socket <= 0)
1421                                 continue;
1422                         log_debugx("closing socket for %s, portal-group \"%s\"",
1423                             oldp->p_listen, oldpg->pg_name);
1424                         close(oldp->p_socket);
1425                         oldp->p_socket = 0;
1426                 }
1427         }
1428
1429         return (cumulated_error);
1430 }
1431
1432 bool
1433 timed_out(void)
1434 {
1435
1436         return (sigalrm_received);
1437 }
1438
1439 static void
1440 sigalrm_handler(int dummy __unused)
1441 {
1442         /*
1443          * It would be easiest to just log an error and exit.  We can't
1444          * do this, though, because log_errx() is not signal safe, since
1445          * it calls syslog(3).  Instead, set a flag checked by pdu_send()
1446          * and pdu_receive(), to call log_errx() there.  Should they fail
1447          * to notice, we'll exit here one second later.
1448          */
1449         if (sigalrm_received) {
1450                 /*
1451                  * Oh well.  Just give up and quit.
1452                  */
1453                 _exit(2);
1454         }
1455
1456         sigalrm_received = true;
1457 }
1458
1459 static void
1460 set_timeout(const struct conf *conf)
1461 {
1462         struct sigaction sa;
1463         struct itimerval itv;
1464         int error;
1465
1466         if (conf->conf_timeout <= 0) {
1467                 log_debugx("session timeout disabled");
1468                 return;
1469         }
1470
1471         bzero(&sa, sizeof(sa));
1472         sa.sa_handler = sigalrm_handler;
1473         sigfillset(&sa.sa_mask);
1474         error = sigaction(SIGALRM, &sa, NULL);
1475         if (error != 0)
1476                 log_err(1, "sigaction");
1477
1478         /*
1479          * First SIGALRM will arive after conf_timeout seconds.
1480          * If we do nothing, another one will arrive a second later.
1481          */
1482         bzero(&itv, sizeof(itv));
1483         itv.it_interval.tv_sec = 1;
1484         itv.it_value.tv_sec = conf->conf_timeout;
1485
1486         log_debugx("setting session timeout to %d seconds",
1487             conf->conf_timeout);
1488         error = setitimer(ITIMER_REAL, &itv, NULL);
1489         if (error != 0)
1490                 log_err(1, "setitimer");
1491 }
1492
1493 static int
1494 wait_for_children(bool block)
1495 {
1496         pid_t pid;
1497         int status;
1498         int num = 0;
1499
1500         for (;;) {
1501                 /*
1502                  * If "block" is true, wait for at least one process.
1503                  */
1504                 if (block && num == 0)
1505                         pid = wait4(-1, &status, 0, NULL);
1506                 else
1507                         pid = wait4(-1, &status, WNOHANG, NULL);
1508                 if (pid <= 0)
1509                         break;
1510                 if (WIFSIGNALED(status)) {
1511                         log_warnx("child process %d terminated with signal %d",
1512                             pid, WTERMSIG(status));
1513                 } else if (WEXITSTATUS(status) != 0) {
1514                         log_warnx("child process %d terminated with exit status %d",
1515                             pid, WEXITSTATUS(status));
1516                 } else {
1517                         log_debugx("child process %d terminated gracefully", pid);
1518                 }
1519                 num++;
1520         }
1521
1522         return (num);
1523 }
1524
1525 static void
1526 handle_connection(struct portal *portal, int fd, bool dont_fork)
1527 {
1528         struct connection *conn;
1529 #ifndef ICL_KERNEL_PROXY
1530         struct sockaddr_storage ss;
1531         socklen_t sslen = sizeof(ss);
1532         int error;
1533 #endif
1534         pid_t pid;
1535         char host[NI_MAXHOST + 1];
1536         struct conf *conf;
1537
1538         conf = portal->p_portal_group->pg_conf;
1539
1540         if (dont_fork) {
1541                 log_debugx("incoming connection; not forking due to -d flag");
1542         } else {
1543                 nchildren -= wait_for_children(false);
1544                 assert(nchildren >= 0);
1545
1546                 while (conf->conf_maxproc > 0 && nchildren >= conf->conf_maxproc) {
1547                         log_debugx("maxproc limit of %d child processes hit; "
1548                             "waiting for child process to exit", conf->conf_maxproc);
1549                         nchildren -= wait_for_children(true);
1550                         assert(nchildren >= 0);
1551                 }
1552                 log_debugx("incoming connection; forking child process #%d",
1553                     nchildren);
1554                 nchildren++;
1555                 pid = fork();
1556                 if (pid < 0)
1557                         log_err(1, "fork");
1558                 if (pid > 0) {
1559                         close(fd);
1560                         return;
1561                 }
1562         }
1563         pidfile_close(conf->conf_pidfh);
1564
1565 #ifdef ICL_KERNEL_PROXY
1566         /*
1567          * XXX
1568          */
1569         log_set_peer_addr("XXX");
1570 #else
1571         error = getpeername(fd, (struct sockaddr *)&ss, &sslen);
1572         if (error != 0)
1573                 log_err(1, "getpeername");
1574         error = getnameinfo((struct sockaddr *)&ss, sslen,
1575             host, sizeof(host), NULL, 0, NI_NUMERICHOST);
1576         if (error != 0)
1577                 log_errx(1, "getaddrinfo: %s", gai_strerror(error));
1578
1579         log_debugx("accepted connection from %s; portal group \"%s\"",
1580             host, portal->p_portal_group->pg_name);
1581         log_set_peer_addr(host);
1582         setproctitle("%s", host);
1583 #endif
1584
1585         conn = connection_new(portal, fd, host);
1586         set_timeout(conf);
1587         kernel_capsicate();
1588         login(conn);
1589         if (conn->conn_session_type == CONN_SESSION_TYPE_NORMAL) {
1590                 kernel_handoff(conn);
1591                 log_debugx("connection handed off to the kernel");
1592         } else {
1593                 assert(conn->conn_session_type == CONN_SESSION_TYPE_DISCOVERY);
1594                 discovery(conn);
1595         }
1596         log_debugx("nothing more to do; exiting");
1597         exit(0);
1598 }
1599
1600 #ifndef ICL_KERNEL_PROXY
1601 static int
1602 fd_add(int fd, fd_set *fdset, int nfds)
1603 {
1604
1605         /*
1606          * Skip sockets which we failed to bind.
1607          */
1608         if (fd <= 0)
1609                 return (nfds);
1610
1611         FD_SET(fd, fdset);
1612         if (fd > nfds)
1613                 nfds = fd;
1614         return (nfds);
1615 }
1616 #endif
1617
1618 static void
1619 main_loop(struct conf *conf, bool dont_fork)
1620 {
1621         struct portal_group *pg;
1622         struct portal *portal;
1623 #ifdef ICL_KERNEL_PROXY
1624         int connection_id;
1625 #else
1626         fd_set fdset;
1627         int error, nfds, client_fd;
1628 #endif
1629
1630         pidfile_write(conf->conf_pidfh);
1631
1632         for (;;) {
1633                 if (sighup_received || sigterm_received)
1634                         return;
1635
1636 #ifdef ICL_KERNEL_PROXY
1637                 connection_id = kernel_accept();
1638                 if (connection_id == 0)
1639                         continue;
1640
1641                 /*
1642                  * XXX: This is obviously temporary.
1643                  */
1644                 pg = TAILQ_FIRST(&conf->conf_portal_groups);
1645                 portal = TAILQ_FIRST(&pg->pg_portals);
1646
1647                 handle_connection(portal, connection_id, dont_fork);
1648 #else
1649                 FD_ZERO(&fdset);
1650                 nfds = 0;
1651                 TAILQ_FOREACH(pg, &conf->conf_portal_groups, pg_next) {
1652                         TAILQ_FOREACH(portal, &pg->pg_portals, p_next)
1653                                 nfds = fd_add(portal->p_socket, &fdset, nfds);
1654                 }
1655                 error = select(nfds + 1, &fdset, NULL, NULL, NULL);
1656                 if (error <= 0) {
1657                         if (errno == EINTR)
1658                                 return;
1659                         log_err(1, "select");
1660                 }
1661                 TAILQ_FOREACH(pg, &conf->conf_portal_groups, pg_next) {
1662                         TAILQ_FOREACH(portal, &pg->pg_portals, p_next) {
1663                                 if (!FD_ISSET(portal->p_socket, &fdset))
1664                                         continue;
1665                                 client_fd = accept(portal->p_socket, NULL, 0);
1666                                 if (client_fd < 0)
1667                                         log_err(1, "accept");
1668                                 handle_connection(portal, client_fd, dont_fork);
1669                                 break;
1670                         }
1671                 }
1672 #endif /* !ICL_KERNEL_PROXY */
1673         }
1674 }
1675
1676 static void
1677 sighup_handler(int dummy __unused)
1678 {
1679
1680         sighup_received = true;
1681 }
1682
1683 static void
1684 sigterm_handler(int dummy __unused)
1685 {
1686
1687         sigterm_received = true;
1688 }
1689
1690 static void
1691 register_signals(void)
1692 {
1693         struct sigaction sa;
1694         int error;
1695
1696         bzero(&sa, sizeof(sa));
1697         sa.sa_handler = sighup_handler;
1698         sigfillset(&sa.sa_mask);
1699         error = sigaction(SIGHUP, &sa, NULL);
1700         if (error != 0)
1701                 log_err(1, "sigaction");
1702
1703         sa.sa_handler = sigterm_handler;
1704         error = sigaction(SIGTERM, &sa, NULL);
1705         if (error != 0)
1706                 log_err(1, "sigaction");
1707
1708         sa.sa_handler = sigterm_handler;
1709         error = sigaction(SIGINT, &sa, NULL);
1710         if (error != 0)
1711                 log_err(1, "sigaction");
1712 }
1713
1714 int
1715 main(int argc, char **argv)
1716 {
1717         struct conf *oldconf, *newconf, *tmpconf;
1718         const char *config_path = DEFAULT_CONFIG_PATH;
1719         int debug = 0, ch, error;
1720         bool dont_daemonize = false;
1721
1722         while ((ch = getopt(argc, argv, "df:")) != -1) {
1723                 switch (ch) {
1724                 case 'd':
1725                         dont_daemonize = true;
1726                         debug++;
1727                         break;
1728                 case 'f':
1729                         config_path = optarg;
1730                         break;
1731                 case '?':
1732                 default:
1733                         usage();
1734                 }
1735         }
1736         argc -= optind;
1737         if (argc != 0)
1738                 usage();
1739
1740         log_init(debug);
1741         kernel_init();
1742
1743         oldconf = conf_new_from_kernel();
1744         newconf = conf_new_from_file(config_path);
1745         if (newconf == NULL)
1746                 log_errx(1, "configuration error, exiting");
1747         if (debug > 0) {
1748                 oldconf->conf_debug = debug;
1749                 newconf->conf_debug = debug;
1750         }
1751
1752 #ifdef ICL_KERNEL_PROXY
1753         log_debugx("enabling CTL iSCSI port");
1754         error = kernel_port_on();
1755         if (error != 0)
1756                 log_errx(1, "failed to enable CTL iSCSI port, exiting");
1757 #endif
1758
1759         error = conf_apply(oldconf, newconf);
1760         if (error != 0)
1761                 log_errx(1, "failed to apply configuration, exiting");
1762         conf_delete(oldconf);
1763         oldconf = NULL;
1764
1765         register_signals();
1766
1767 #ifndef ICL_KERNEL_PROXY
1768         log_debugx("enabling CTL iSCSI port");
1769         error = kernel_port_on();
1770         if (error != 0)
1771                 log_errx(1, "failed to enable CTL iSCSI port, exiting");
1772 #endif
1773
1774         if (dont_daemonize == false) {
1775                 log_debugx("daemonizing");
1776                 if (daemon(0, 0) == -1) {
1777                         log_warn("cannot daemonize");
1778                         pidfile_remove(newconf->conf_pidfh);
1779                         exit(1);
1780                 }
1781         }
1782
1783         for (;;) {
1784                 main_loop(newconf, dont_daemonize);
1785                 if (sighup_received) {
1786                         sighup_received = false;
1787                         log_debugx("received SIGHUP, reloading configuration");
1788                         tmpconf = conf_new_from_file(config_path);
1789                         if (tmpconf == NULL) {
1790                                 log_warnx("configuration error, "
1791                                     "continuing with old configuration");
1792                         } else {
1793                                 if (debug > 0)
1794                                         tmpconf->conf_debug = debug;
1795                                 oldconf = newconf;
1796                                 newconf = tmpconf;
1797                                 error = conf_apply(oldconf, newconf);
1798                                 if (error != 0)
1799                                         log_warnx("failed to reload "
1800                                             "configuration");
1801                                 conf_delete(oldconf);
1802                                 oldconf = NULL;
1803                         }
1804                 } else if (sigterm_received) {
1805                         log_debugx("exiting on signal; "
1806                             "reloading empty configuration");
1807
1808                         log_debugx("disabling CTL iSCSI port "
1809                             "and terminating all connections");
1810                         error = kernel_port_off();
1811                         if (error != 0)
1812                                 log_warnx("failed to disable CTL iSCSI port");
1813
1814                         oldconf = newconf;
1815                         newconf = conf_new();
1816                         if (debug > 0)
1817                                 newconf->conf_debug = debug;
1818                         error = conf_apply(oldconf, newconf);
1819                         if (error != 0)
1820                                 log_warnx("failed to apply configuration");
1821
1822                         log_warnx("exiting on signal");
1823                         exit(0);
1824                 } else {
1825                         nchildren -= wait_for_children(false);
1826                         assert(nchildren >= 0);
1827                 }
1828         }
1829         /* NOTREACHED */
1830 }