Decouple the send and receive limits on the amount of data in a single iSCSI PDU. MaxRecvDataSegmentLength is declarative, not negotiated, and is direction-specific so there is no reason for both ends to limit themselves to the same min(initiator, target) value in both directions. Allow iSCSI drivers to report their send, receive, first burst, and max burst limits explicitly instead of using hardcoded values or trying to derive all of them from the receive limit (which was the only limit reported by the drivers prior to this change). Display the send and receive limits separately in the userspace iSCSI utilities. Reviewed by: jpaetzel@ (earlier version), trasz@ Sponsored by: Chelsio Communications Differential Revision: https://reviews.freebsd.org/D7279
2727 lines
63 KiB
C
2727 lines
63 KiB
C
/*-
|
|
* Copyright (c) 2012 The FreeBSD Foundation
|
|
* All rights reserved.
|
|
*
|
|
* This software was developed by Edward Tomasz Napierala under sponsorship
|
|
* from the FreeBSD Foundation.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/time.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/wait.h>
|
|
#include <netinet/in.h>
|
|
#include <arpa/inet.h>
|
|
#include <assert.h>
|
|
#include <ctype.h>
|
|
#include <errno.h>
|
|
#include <netdb.h>
|
|
#include <signal.h>
|
|
#include <stdbool.h>
|
|
#include <stdio.h>
|
|
#include <stdint.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
|
|
#include "ctld.h"
|
|
#include "isns.h"
|
|
|
|
bool proxy_mode = false;
|
|
|
|
static volatile bool sighup_received = false;
|
|
static volatile bool sigterm_received = false;
|
|
static volatile bool sigalrm_received = false;
|
|
|
|
static int nchildren = 0;
|
|
static uint16_t last_portal_group_tag = 0xff;
|
|
|
|
static void
|
|
usage(void)
|
|
{
|
|
|
|
fprintf(stderr, "usage: ctld [-d][-u][-f config-file]\n");
|
|
exit(1);
|
|
}
|
|
|
|
char *
|
|
checked_strdup(const char *s)
|
|
{
|
|
char *c;
|
|
|
|
c = strdup(s);
|
|
if (c == NULL)
|
|
log_err(1, "strdup");
|
|
return (c);
|
|
}
|
|
|
|
struct conf *
|
|
conf_new(void)
|
|
{
|
|
struct conf *conf;
|
|
|
|
conf = calloc(1, sizeof(*conf));
|
|
if (conf == NULL)
|
|
log_err(1, "calloc");
|
|
TAILQ_INIT(&conf->conf_luns);
|
|
TAILQ_INIT(&conf->conf_targets);
|
|
TAILQ_INIT(&conf->conf_auth_groups);
|
|
TAILQ_INIT(&conf->conf_ports);
|
|
TAILQ_INIT(&conf->conf_portal_groups);
|
|
TAILQ_INIT(&conf->conf_pports);
|
|
TAILQ_INIT(&conf->conf_isns);
|
|
|
|
conf->conf_isns_period = 900;
|
|
conf->conf_isns_timeout = 5;
|
|
conf->conf_debug = 0;
|
|
conf->conf_timeout = 60;
|
|
conf->conf_maxproc = 30;
|
|
|
|
return (conf);
|
|
}
|
|
|
|
void
|
|
conf_delete(struct conf *conf)
|
|
{
|
|
struct lun *lun, *ltmp;
|
|
struct target *targ, *tmp;
|
|
struct auth_group *ag, *cagtmp;
|
|
struct portal_group *pg, *cpgtmp;
|
|
struct pport *pp, *pptmp;
|
|
struct isns *is, *istmp;
|
|
|
|
assert(conf->conf_pidfh == NULL);
|
|
|
|
TAILQ_FOREACH_SAFE(lun, &conf->conf_luns, l_next, ltmp)
|
|
lun_delete(lun);
|
|
TAILQ_FOREACH_SAFE(targ, &conf->conf_targets, t_next, tmp)
|
|
target_delete(targ);
|
|
TAILQ_FOREACH_SAFE(ag, &conf->conf_auth_groups, ag_next, cagtmp)
|
|
auth_group_delete(ag);
|
|
TAILQ_FOREACH_SAFE(pg, &conf->conf_portal_groups, pg_next, cpgtmp)
|
|
portal_group_delete(pg);
|
|
TAILQ_FOREACH_SAFE(pp, &conf->conf_pports, pp_next, pptmp)
|
|
pport_delete(pp);
|
|
TAILQ_FOREACH_SAFE(is, &conf->conf_isns, i_next, istmp)
|
|
isns_delete(is);
|
|
assert(TAILQ_EMPTY(&conf->conf_ports));
|
|
free(conf->conf_pidfile_path);
|
|
free(conf);
|
|
}
|
|
|
|
static struct auth *
|
|
auth_new(struct auth_group *ag)
|
|
{
|
|
struct auth *auth;
|
|
|
|
auth = calloc(1, sizeof(*auth));
|
|
if (auth == NULL)
|
|
log_err(1, "calloc");
|
|
auth->a_auth_group = ag;
|
|
TAILQ_INSERT_TAIL(&ag->ag_auths, auth, a_next);
|
|
return (auth);
|
|
}
|
|
|
|
static void
|
|
auth_delete(struct auth *auth)
|
|
{
|
|
TAILQ_REMOVE(&auth->a_auth_group->ag_auths, auth, a_next);
|
|
|
|
free(auth->a_user);
|
|
free(auth->a_secret);
|
|
free(auth->a_mutual_user);
|
|
free(auth->a_mutual_secret);
|
|
free(auth);
|
|
}
|
|
|
|
const struct auth *
|
|
auth_find(const struct auth_group *ag, const char *user)
|
|
{
|
|
const struct auth *auth;
|
|
|
|
TAILQ_FOREACH(auth, &ag->ag_auths, a_next) {
|
|
if (strcmp(auth->a_user, user) == 0)
|
|
return (auth);
|
|
}
|
|
|
|
return (NULL);
|
|
}
|
|
|
|
static void
|
|
auth_check_secret_length(struct auth *auth)
|
|
{
|
|
size_t len;
|
|
|
|
len = strlen(auth->a_secret);
|
|
if (len > 16) {
|
|
if (auth->a_auth_group->ag_name != NULL)
|
|
log_warnx("secret for user \"%s\", auth-group \"%s\", "
|
|
"is too long; it should be at most 16 characters "
|
|
"long", auth->a_user, auth->a_auth_group->ag_name);
|
|
else
|
|
log_warnx("secret for user \"%s\", target \"%s\", "
|
|
"is too long; it should be at most 16 characters "
|
|
"long", auth->a_user,
|
|
auth->a_auth_group->ag_target->t_name);
|
|
}
|
|
if (len < 12) {
|
|
if (auth->a_auth_group->ag_name != NULL)
|
|
log_warnx("secret for user \"%s\", auth-group \"%s\", "
|
|
"is too short; it should be at least 12 characters "
|
|
"long", auth->a_user,
|
|
auth->a_auth_group->ag_name);
|
|
else
|
|
log_warnx("secret for user \"%s\", target \"%s\", "
|
|
"is too short; it should be at least 16 characters "
|
|
"long", auth->a_user,
|
|
auth->a_auth_group->ag_target->t_name);
|
|
}
|
|
|
|
if (auth->a_mutual_secret != NULL) {
|
|
len = strlen(auth->a_mutual_secret);
|
|
if (len > 16) {
|
|
if (auth->a_auth_group->ag_name != NULL)
|
|
log_warnx("mutual secret for user \"%s\", "
|
|
"auth-group \"%s\", is too long; it should "
|
|
"be at most 16 characters long",
|
|
auth->a_user, auth->a_auth_group->ag_name);
|
|
else
|
|
log_warnx("mutual secret for user \"%s\", "
|
|
"target \"%s\", is too long; it should "
|
|
"be at most 16 characters long",
|
|
auth->a_user,
|
|
auth->a_auth_group->ag_target->t_name);
|
|
}
|
|
if (len < 12) {
|
|
if (auth->a_auth_group->ag_name != NULL)
|
|
log_warnx("mutual secret for user \"%s\", "
|
|
"auth-group \"%s\", is too short; it "
|
|
"should be at least 12 characters long",
|
|
auth->a_user, auth->a_auth_group->ag_name);
|
|
else
|
|
log_warnx("mutual secret for user \"%s\", "
|
|
"target \"%s\", is too short; it should be "
|
|
"at least 16 characters long",
|
|
auth->a_user,
|
|
auth->a_auth_group->ag_target->t_name);
|
|
}
|
|
}
|
|
}
|
|
|
|
const struct auth *
|
|
auth_new_chap(struct auth_group *ag, const char *user,
|
|
const char *secret)
|
|
{
|
|
struct auth *auth;
|
|
|
|
if (ag->ag_type == AG_TYPE_UNKNOWN)
|
|
ag->ag_type = AG_TYPE_CHAP;
|
|
if (ag->ag_type != AG_TYPE_CHAP) {
|
|
if (ag->ag_name != NULL)
|
|
log_warnx("cannot mix \"chap\" authentication with "
|
|
"other types for auth-group \"%s\"", ag->ag_name);
|
|
else
|
|
log_warnx("cannot mix \"chap\" authentication with "
|
|
"other types for target \"%s\"",
|
|
ag->ag_target->t_name);
|
|
return (NULL);
|
|
}
|
|
|
|
auth = auth_new(ag);
|
|
auth->a_user = checked_strdup(user);
|
|
auth->a_secret = checked_strdup(secret);
|
|
|
|
auth_check_secret_length(auth);
|
|
|
|
return (auth);
|
|
}
|
|
|
|
const struct auth *
|
|
auth_new_chap_mutual(struct auth_group *ag, const char *user,
|
|
const char *secret, const char *user2, const char *secret2)
|
|
{
|
|
struct auth *auth;
|
|
|
|
if (ag->ag_type == AG_TYPE_UNKNOWN)
|
|
ag->ag_type = AG_TYPE_CHAP_MUTUAL;
|
|
if (ag->ag_type != AG_TYPE_CHAP_MUTUAL) {
|
|
if (ag->ag_name != NULL)
|
|
log_warnx("cannot mix \"chap-mutual\" authentication "
|
|
"with other types for auth-group \"%s\"",
|
|
ag->ag_name);
|
|
else
|
|
log_warnx("cannot mix \"chap-mutual\" authentication "
|
|
"with other types for target \"%s\"",
|
|
ag->ag_target->t_name);
|
|
return (NULL);
|
|
}
|
|
|
|
auth = auth_new(ag);
|
|
auth->a_user = checked_strdup(user);
|
|
auth->a_secret = checked_strdup(secret);
|
|
auth->a_mutual_user = checked_strdup(user2);
|
|
auth->a_mutual_secret = checked_strdup(secret2);
|
|
|
|
auth_check_secret_length(auth);
|
|
|
|
return (auth);
|
|
}
|
|
|
|
const struct auth_name *
|
|
auth_name_new(struct auth_group *ag, const char *name)
|
|
{
|
|
struct auth_name *an;
|
|
|
|
an = calloc(1, sizeof(*an));
|
|
if (an == NULL)
|
|
log_err(1, "calloc");
|
|
an->an_auth_group = ag;
|
|
an->an_initator_name = checked_strdup(name);
|
|
TAILQ_INSERT_TAIL(&ag->ag_names, an, an_next);
|
|
return (an);
|
|
}
|
|
|
|
static void
|
|
auth_name_delete(struct auth_name *an)
|
|
{
|
|
TAILQ_REMOVE(&an->an_auth_group->ag_names, an, an_next);
|
|
|
|
free(an->an_initator_name);
|
|
free(an);
|
|
}
|
|
|
|
bool
|
|
auth_name_defined(const struct auth_group *ag)
|
|
{
|
|
if (TAILQ_EMPTY(&ag->ag_names))
|
|
return (false);
|
|
return (true);
|
|
}
|
|
|
|
const struct auth_name *
|
|
auth_name_find(const struct auth_group *ag, const char *name)
|
|
{
|
|
const struct auth_name *auth_name;
|
|
|
|
TAILQ_FOREACH(auth_name, &ag->ag_names, an_next) {
|
|
if (strcmp(auth_name->an_initator_name, name) == 0)
|
|
return (auth_name);
|
|
}
|
|
|
|
return (NULL);
|
|
}
|
|
|
|
int
|
|
auth_name_check(const struct auth_group *ag, const char *initiator_name)
|
|
{
|
|
if (!auth_name_defined(ag))
|
|
return (0);
|
|
|
|
if (auth_name_find(ag, initiator_name) == NULL)
|
|
return (1);
|
|
|
|
return (0);
|
|
}
|
|
|
|
const struct auth_portal *
|
|
auth_portal_new(struct auth_group *ag, const char *portal)
|
|
{
|
|
struct auth_portal *ap;
|
|
char *net, *mask, *str, *tmp;
|
|
int len, dm, m;
|
|
|
|
ap = calloc(1, sizeof(*ap));
|
|
if (ap == NULL)
|
|
log_err(1, "calloc");
|
|
ap->ap_auth_group = ag;
|
|
ap->ap_initator_portal = checked_strdup(portal);
|
|
mask = str = checked_strdup(portal);
|
|
net = strsep(&mask, "/");
|
|
if (net[0] == '[')
|
|
net++;
|
|
len = strlen(net);
|
|
if (len == 0)
|
|
goto error;
|
|
if (net[len - 1] == ']')
|
|
net[len - 1] = 0;
|
|
if (strchr(net, ':') != NULL) {
|
|
struct sockaddr_in6 *sin6 =
|
|
(struct sockaddr_in6 *)&ap->ap_sa;
|
|
|
|
sin6->sin6_len = sizeof(*sin6);
|
|
sin6->sin6_family = AF_INET6;
|
|
if (inet_pton(AF_INET6, net, &sin6->sin6_addr) <= 0)
|
|
goto error;
|
|
dm = 128;
|
|
} else {
|
|
struct sockaddr_in *sin =
|
|
(struct sockaddr_in *)&ap->ap_sa;
|
|
|
|
sin->sin_len = sizeof(*sin);
|
|
sin->sin_family = AF_INET;
|
|
if (inet_pton(AF_INET, net, &sin->sin_addr) <= 0)
|
|
goto error;
|
|
dm = 32;
|
|
}
|
|
if (mask != NULL) {
|
|
m = strtol(mask, &tmp, 0);
|
|
if (m < 0 || m > dm || tmp[0] != 0)
|
|
goto error;
|
|
} else
|
|
m = dm;
|
|
ap->ap_mask = m;
|
|
free(str);
|
|
TAILQ_INSERT_TAIL(&ag->ag_portals, ap, ap_next);
|
|
return (ap);
|
|
|
|
error:
|
|
free(ap);
|
|
log_warnx("incorrect initiator portal \"%s\"", portal);
|
|
return (NULL);
|
|
}
|
|
|
|
static void
|
|
auth_portal_delete(struct auth_portal *ap)
|
|
{
|
|
TAILQ_REMOVE(&ap->ap_auth_group->ag_portals, ap, ap_next);
|
|
|
|
free(ap->ap_initator_portal);
|
|
free(ap);
|
|
}
|
|
|
|
bool
|
|
auth_portal_defined(const struct auth_group *ag)
|
|
{
|
|
if (TAILQ_EMPTY(&ag->ag_portals))
|
|
return (false);
|
|
return (true);
|
|
}
|
|
|
|
const struct auth_portal *
|
|
auth_portal_find(const struct auth_group *ag, const struct sockaddr_storage *ss)
|
|
{
|
|
const struct auth_portal *ap;
|
|
const uint8_t *a, *b;
|
|
int i;
|
|
uint8_t bmask;
|
|
|
|
TAILQ_FOREACH(ap, &ag->ag_portals, ap_next) {
|
|
if (ap->ap_sa.ss_family != ss->ss_family)
|
|
continue;
|
|
if (ss->ss_family == AF_INET) {
|
|
a = (const uint8_t *)
|
|
&((const struct sockaddr_in *)ss)->sin_addr;
|
|
b = (const uint8_t *)
|
|
&((const struct sockaddr_in *)&ap->ap_sa)->sin_addr;
|
|
} else {
|
|
a = (const uint8_t *)
|
|
&((const struct sockaddr_in6 *)ss)->sin6_addr;
|
|
b = (const uint8_t *)
|
|
&((const struct sockaddr_in6 *)&ap->ap_sa)->sin6_addr;
|
|
}
|
|
for (i = 0; i < ap->ap_mask / 8; i++) {
|
|
if (a[i] != b[i])
|
|
goto next;
|
|
}
|
|
if (ap->ap_mask % 8) {
|
|
bmask = 0xff << (8 - (ap->ap_mask % 8));
|
|
if ((a[i] & bmask) != (b[i] & bmask))
|
|
goto next;
|
|
}
|
|
return (ap);
|
|
next:
|
|
;
|
|
}
|
|
|
|
return (NULL);
|
|
}
|
|
|
|
int
|
|
auth_portal_check(const struct auth_group *ag, const struct sockaddr_storage *sa)
|
|
{
|
|
|
|
if (!auth_portal_defined(ag))
|
|
return (0);
|
|
|
|
if (auth_portal_find(ag, sa) == NULL)
|
|
return (1);
|
|
|
|
return (0);
|
|
}
|
|
|
|
struct auth_group *
|
|
auth_group_new(struct conf *conf, const char *name)
|
|
{
|
|
struct auth_group *ag;
|
|
|
|
if (name != NULL) {
|
|
ag = auth_group_find(conf, name);
|
|
if (ag != NULL) {
|
|
log_warnx("duplicated auth-group \"%s\"", name);
|
|
return (NULL);
|
|
}
|
|
}
|
|
|
|
ag = calloc(1, sizeof(*ag));
|
|
if (ag == NULL)
|
|
log_err(1, "calloc");
|
|
if (name != NULL)
|
|
ag->ag_name = checked_strdup(name);
|
|
TAILQ_INIT(&ag->ag_auths);
|
|
TAILQ_INIT(&ag->ag_names);
|
|
TAILQ_INIT(&ag->ag_portals);
|
|
ag->ag_conf = conf;
|
|
TAILQ_INSERT_TAIL(&conf->conf_auth_groups, ag, ag_next);
|
|
|
|
return (ag);
|
|
}
|
|
|
|
void
|
|
auth_group_delete(struct auth_group *ag)
|
|
{
|
|
struct auth *auth, *auth_tmp;
|
|
struct auth_name *auth_name, *auth_name_tmp;
|
|
struct auth_portal *auth_portal, *auth_portal_tmp;
|
|
|
|
TAILQ_REMOVE(&ag->ag_conf->conf_auth_groups, ag, ag_next);
|
|
|
|
TAILQ_FOREACH_SAFE(auth, &ag->ag_auths, a_next, auth_tmp)
|
|
auth_delete(auth);
|
|
TAILQ_FOREACH_SAFE(auth_name, &ag->ag_names, an_next, auth_name_tmp)
|
|
auth_name_delete(auth_name);
|
|
TAILQ_FOREACH_SAFE(auth_portal, &ag->ag_portals, ap_next,
|
|
auth_portal_tmp)
|
|
auth_portal_delete(auth_portal);
|
|
free(ag->ag_name);
|
|
free(ag);
|
|
}
|
|
|
|
struct auth_group *
|
|
auth_group_find(const struct conf *conf, const char *name)
|
|
{
|
|
struct auth_group *ag;
|
|
|
|
TAILQ_FOREACH(ag, &conf->conf_auth_groups, ag_next) {
|
|
if (ag->ag_name != NULL && strcmp(ag->ag_name, name) == 0)
|
|
return (ag);
|
|
}
|
|
|
|
return (NULL);
|
|
}
|
|
|
|
int
|
|
auth_group_set_type(struct auth_group *ag, const char *str)
|
|
{
|
|
int type;
|
|
|
|
if (strcmp(str, "none") == 0) {
|
|
type = AG_TYPE_NO_AUTHENTICATION;
|
|
} else if (strcmp(str, "deny") == 0) {
|
|
type = AG_TYPE_DENY;
|
|
} else if (strcmp(str, "chap") == 0) {
|
|
type = AG_TYPE_CHAP;
|
|
} else if (strcmp(str, "chap-mutual") == 0) {
|
|
type = AG_TYPE_CHAP_MUTUAL;
|
|
} else {
|
|
if (ag->ag_name != NULL)
|
|
log_warnx("invalid auth-type \"%s\" for auth-group "
|
|
"\"%s\"", str, ag->ag_name);
|
|
else
|
|
log_warnx("invalid auth-type \"%s\" for target "
|
|
"\"%s\"", str, ag->ag_target->t_name);
|
|
return (1);
|
|
}
|
|
|
|
if (ag->ag_type != AG_TYPE_UNKNOWN && ag->ag_type != type) {
|
|
if (ag->ag_name != NULL) {
|
|
log_warnx("cannot set auth-type to \"%s\" for "
|
|
"auth-group \"%s\"; already has a different "
|
|
"type", str, ag->ag_name);
|
|
} else {
|
|
log_warnx("cannot set auth-type to \"%s\" for target "
|
|
"\"%s\"; already has a different type",
|
|
str, ag->ag_target->t_name);
|
|
}
|
|
return (1);
|
|
}
|
|
|
|
ag->ag_type = type;
|
|
|
|
return (0);
|
|
}
|
|
|
|
static struct portal *
|
|
portal_new(struct portal_group *pg)
|
|
{
|
|
struct portal *portal;
|
|
|
|
portal = calloc(1, sizeof(*portal));
|
|
if (portal == NULL)
|
|
log_err(1, "calloc");
|
|
TAILQ_INIT(&portal->p_targets);
|
|
portal->p_portal_group = pg;
|
|
TAILQ_INSERT_TAIL(&pg->pg_portals, portal, p_next);
|
|
return (portal);
|
|
}
|
|
|
|
static void
|
|
portal_delete(struct portal *portal)
|
|
{
|
|
|
|
TAILQ_REMOVE(&portal->p_portal_group->pg_portals, portal, p_next);
|
|
if (portal->p_ai != NULL)
|
|
freeaddrinfo(portal->p_ai);
|
|
free(portal->p_listen);
|
|
free(portal);
|
|
}
|
|
|
|
struct portal_group *
|
|
portal_group_new(struct conf *conf, const char *name)
|
|
{
|
|
struct portal_group *pg;
|
|
|
|
pg = portal_group_find(conf, name);
|
|
if (pg != NULL) {
|
|
log_warnx("duplicated portal-group \"%s\"", name);
|
|
return (NULL);
|
|
}
|
|
|
|
pg = calloc(1, sizeof(*pg));
|
|
if (pg == NULL)
|
|
log_err(1, "calloc");
|
|
pg->pg_name = checked_strdup(name);
|
|
TAILQ_INIT(&pg->pg_options);
|
|
TAILQ_INIT(&pg->pg_portals);
|
|
TAILQ_INIT(&pg->pg_ports);
|
|
pg->pg_conf = conf;
|
|
pg->pg_tag = 0; /* Assigned later in conf_apply(). */
|
|
TAILQ_INSERT_TAIL(&conf->conf_portal_groups, pg, pg_next);
|
|
|
|
return (pg);
|
|
}
|
|
|
|
void
|
|
portal_group_delete(struct portal_group *pg)
|
|
{
|
|
struct portal *portal, *tmp;
|
|
struct port *port, *tport;
|
|
struct option *o, *otmp;
|
|
|
|
TAILQ_FOREACH_SAFE(port, &pg->pg_ports, p_pgs, tport)
|
|
port_delete(port);
|
|
TAILQ_REMOVE(&pg->pg_conf->conf_portal_groups, pg, pg_next);
|
|
|
|
TAILQ_FOREACH_SAFE(portal, &pg->pg_portals, p_next, tmp)
|
|
portal_delete(portal);
|
|
TAILQ_FOREACH_SAFE(o, &pg->pg_options, o_next, otmp)
|
|
option_delete(&pg->pg_options, o);
|
|
free(pg->pg_name);
|
|
free(pg->pg_offload);
|
|
free(pg->pg_redirection);
|
|
free(pg);
|
|
}
|
|
|
|
struct portal_group *
|
|
portal_group_find(const struct conf *conf, const char *name)
|
|
{
|
|
struct portal_group *pg;
|
|
|
|
TAILQ_FOREACH(pg, &conf->conf_portal_groups, pg_next) {
|
|
if (strcmp(pg->pg_name, name) == 0)
|
|
return (pg);
|
|
}
|
|
|
|
return (NULL);
|
|
}
|
|
|
|
static int
|
|
parse_addr_port(char *arg, const char *def_port, struct addrinfo **ai)
|
|
{
|
|
struct addrinfo hints;
|
|
char *str, *addr, *ch;
|
|
const char *port;
|
|
int error, colons = 0;
|
|
|
|
str = arg = strdup(arg);
|
|
if (arg[0] == '[') {
|
|
/*
|
|
* IPv6 address in square brackets, perhaps with port.
|
|
*/
|
|
arg++;
|
|
addr = strsep(&arg, "]");
|
|
if (arg == NULL)
|
|
return (1);
|
|
if (arg[0] == '\0') {
|
|
port = def_port;
|
|
} else if (arg[0] == ':') {
|
|
port = arg + 1;
|
|
} else {
|
|
free(str);
|
|
return (1);
|
|
}
|
|
} else {
|
|
/*
|
|
* Either IPv6 address without brackets - and without
|
|
* a port - or IPv4 address. Just count the colons.
|
|
*/
|
|
for (ch = arg; *ch != '\0'; ch++) {
|
|
if (*ch == ':')
|
|
colons++;
|
|
}
|
|
if (colons > 1) {
|
|
addr = arg;
|
|
port = def_port;
|
|
} else {
|
|
addr = strsep(&arg, ":");
|
|
if (arg == NULL)
|
|
port = def_port;
|
|
else
|
|
port = arg;
|
|
}
|
|
}
|
|
|
|
memset(&hints, 0, sizeof(hints));
|
|
hints.ai_family = PF_UNSPEC;
|
|
hints.ai_socktype = SOCK_STREAM;
|
|
hints.ai_flags = AI_PASSIVE;
|
|
error = getaddrinfo(addr, port, &hints, ai);
|
|
free(str);
|
|
return ((error != 0) ? 1 : 0);
|
|
}
|
|
|
|
int
|
|
portal_group_add_listen(struct portal_group *pg, const char *value, bool iser)
|
|
{
|
|
struct portal *portal;
|
|
|
|
portal = portal_new(pg);
|
|
portal->p_listen = checked_strdup(value);
|
|
portal->p_iser = iser;
|
|
|
|
if (parse_addr_port(portal->p_listen, "3260", &portal->p_ai)) {
|
|
log_warnx("invalid listen address %s", portal->p_listen);
|
|
portal_delete(portal);
|
|
return (1);
|
|
}
|
|
|
|
/*
|
|
* XXX: getaddrinfo(3) may return multiple addresses; we should turn
|
|
* those into multiple portals.
|
|
*/
|
|
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
isns_new(struct conf *conf, const char *addr)
|
|
{
|
|
struct isns *isns;
|
|
|
|
isns = calloc(1, sizeof(*isns));
|
|
if (isns == NULL)
|
|
log_err(1, "calloc");
|
|
isns->i_conf = conf;
|
|
TAILQ_INSERT_TAIL(&conf->conf_isns, isns, i_next);
|
|
isns->i_addr = checked_strdup(addr);
|
|
|
|
if (parse_addr_port(isns->i_addr, "3205", &isns->i_ai)) {
|
|
log_warnx("invalid iSNS address %s", isns->i_addr);
|
|
isns_delete(isns);
|
|
return (1);
|
|
}
|
|
|
|
/*
|
|
* XXX: getaddrinfo(3) may return multiple addresses; we should turn
|
|
* those into multiple servers.
|
|
*/
|
|
|
|
return (0);
|
|
}
|
|
|
|
void
|
|
isns_delete(struct isns *isns)
|
|
{
|
|
|
|
TAILQ_REMOVE(&isns->i_conf->conf_isns, isns, i_next);
|
|
free(isns->i_addr);
|
|
if (isns->i_ai != NULL)
|
|
freeaddrinfo(isns->i_ai);
|
|
free(isns);
|
|
}
|
|
|
|
static int
|
|
isns_do_connect(struct isns *isns)
|
|
{
|
|
int s;
|
|
|
|
s = socket(isns->i_ai->ai_family, isns->i_ai->ai_socktype,
|
|
isns->i_ai->ai_protocol);
|
|
if (s < 0) {
|
|
log_warn("socket(2) failed for %s", isns->i_addr);
|
|
return (-1);
|
|
}
|
|
if (connect(s, isns->i_ai->ai_addr, isns->i_ai->ai_addrlen)) {
|
|
log_warn("connect(2) failed for %s", isns->i_addr);
|
|
close(s);
|
|
return (-1);
|
|
}
|
|
return(s);
|
|
}
|
|
|
|
static int
|
|
isns_do_register(struct isns *isns, int s, const char *hostname)
|
|
{
|
|
struct conf *conf = isns->i_conf;
|
|
struct target *target;
|
|
struct portal *portal;
|
|
struct portal_group *pg;
|
|
struct port *port;
|
|
struct isns_req *req;
|
|
int res = 0;
|
|
uint32_t error;
|
|
|
|
req = isns_req_create(ISNS_FUNC_DEVATTRREG, ISNS_FLAG_CLIENT);
|
|
isns_req_add_str(req, 32, TAILQ_FIRST(&conf->conf_targets)->t_name);
|
|
isns_req_add_delim(req);
|
|
isns_req_add_str(req, 1, hostname);
|
|
isns_req_add_32(req, 2, 2); /* 2 -- iSCSI */
|
|
isns_req_add_32(req, 6, conf->conf_isns_period);
|
|
TAILQ_FOREACH(pg, &conf->conf_portal_groups, pg_next) {
|
|
if (pg->pg_unassigned)
|
|
continue;
|
|
TAILQ_FOREACH(portal, &pg->pg_portals, p_next) {
|
|
isns_req_add_addr(req, 16, portal->p_ai);
|
|
isns_req_add_port(req, 17, portal->p_ai);
|
|
}
|
|
}
|
|
TAILQ_FOREACH(target, &conf->conf_targets, t_next) {
|
|
isns_req_add_str(req, 32, target->t_name);
|
|
isns_req_add_32(req, 33, 1); /* 1 -- Target*/
|
|
if (target->t_alias != NULL)
|
|
isns_req_add_str(req, 34, target->t_alias);
|
|
TAILQ_FOREACH(port, &target->t_ports, p_ts) {
|
|
if ((pg = port->p_portal_group) == NULL)
|
|
continue;
|
|
isns_req_add_32(req, 51, pg->pg_tag);
|
|
TAILQ_FOREACH(portal, &pg->pg_portals, p_next) {
|
|
isns_req_add_addr(req, 49, portal->p_ai);
|
|
isns_req_add_port(req, 50, portal->p_ai);
|
|
}
|
|
}
|
|
}
|
|
res = isns_req_send(s, req);
|
|
if (res < 0) {
|
|
log_warn("send(2) failed for %s", isns->i_addr);
|
|
goto quit;
|
|
}
|
|
res = isns_req_receive(s, req);
|
|
if (res < 0) {
|
|
log_warn("receive(2) failed for %s", isns->i_addr);
|
|
goto quit;
|
|
}
|
|
error = isns_req_get_status(req);
|
|
if (error != 0) {
|
|
log_warnx("iSNS register error %d for %s", error, isns->i_addr);
|
|
res = -1;
|
|
}
|
|
quit:
|
|
isns_req_free(req);
|
|
return (res);
|
|
}
|
|
|
|
static int
|
|
isns_do_check(struct isns *isns, int s, const char *hostname)
|
|
{
|
|
struct conf *conf = isns->i_conf;
|
|
struct isns_req *req;
|
|
int res = 0;
|
|
uint32_t error;
|
|
|
|
req = isns_req_create(ISNS_FUNC_DEVATTRQRY, ISNS_FLAG_CLIENT);
|
|
isns_req_add_str(req, 32, TAILQ_FIRST(&conf->conf_targets)->t_name);
|
|
isns_req_add_str(req, 1, hostname);
|
|
isns_req_add_delim(req);
|
|
isns_req_add(req, 2, 0, NULL);
|
|
res = isns_req_send(s, req);
|
|
if (res < 0) {
|
|
log_warn("send(2) failed for %s", isns->i_addr);
|
|
goto quit;
|
|
}
|
|
res = isns_req_receive(s, req);
|
|
if (res < 0) {
|
|
log_warn("receive(2) failed for %s", isns->i_addr);
|
|
goto quit;
|
|
}
|
|
error = isns_req_get_status(req);
|
|
if (error != 0) {
|
|
log_warnx("iSNS check error %d for %s", error, isns->i_addr);
|
|
res = -1;
|
|
}
|
|
quit:
|
|
isns_req_free(req);
|
|
return (res);
|
|
}
|
|
|
|
static int
|
|
isns_do_deregister(struct isns *isns, int s, const char *hostname)
|
|
{
|
|
struct conf *conf = isns->i_conf;
|
|
struct isns_req *req;
|
|
int res = 0;
|
|
uint32_t error;
|
|
|
|
req = isns_req_create(ISNS_FUNC_DEVDEREG, ISNS_FLAG_CLIENT);
|
|
isns_req_add_str(req, 32, TAILQ_FIRST(&conf->conf_targets)->t_name);
|
|
isns_req_add_delim(req);
|
|
isns_req_add_str(req, 1, hostname);
|
|
res = isns_req_send(s, req);
|
|
if (res < 0) {
|
|
log_warn("send(2) failed for %s", isns->i_addr);
|
|
goto quit;
|
|
}
|
|
res = isns_req_receive(s, req);
|
|
if (res < 0) {
|
|
log_warn("receive(2) failed for %s", isns->i_addr);
|
|
goto quit;
|
|
}
|
|
error = isns_req_get_status(req);
|
|
if (error != 0) {
|
|
log_warnx("iSNS deregister error %d for %s", error, isns->i_addr);
|
|
res = -1;
|
|
}
|
|
quit:
|
|
isns_req_free(req);
|
|
return (res);
|
|
}
|
|
|
|
void
|
|
isns_register(struct isns *isns, struct isns *oldisns)
|
|
{
|
|
struct conf *conf = isns->i_conf;
|
|
int s;
|
|
char hostname[256];
|
|
|
|
if (TAILQ_EMPTY(&conf->conf_targets) ||
|
|
TAILQ_EMPTY(&conf->conf_portal_groups))
|
|
return;
|
|
set_timeout(conf->conf_isns_timeout, false);
|
|
s = isns_do_connect(isns);
|
|
if (s < 0) {
|
|
set_timeout(0, false);
|
|
return;
|
|
}
|
|
gethostname(hostname, sizeof(hostname));
|
|
|
|
if (oldisns == NULL || TAILQ_EMPTY(&oldisns->i_conf->conf_targets))
|
|
oldisns = isns;
|
|
isns_do_deregister(oldisns, s, hostname);
|
|
isns_do_register(isns, s, hostname);
|
|
close(s);
|
|
set_timeout(0, false);
|
|
}
|
|
|
|
void
|
|
isns_check(struct isns *isns)
|
|
{
|
|
struct conf *conf = isns->i_conf;
|
|
int s, res;
|
|
char hostname[256];
|
|
|
|
if (TAILQ_EMPTY(&conf->conf_targets) ||
|
|
TAILQ_EMPTY(&conf->conf_portal_groups))
|
|
return;
|
|
set_timeout(conf->conf_isns_timeout, false);
|
|
s = isns_do_connect(isns);
|
|
if (s < 0) {
|
|
set_timeout(0, false);
|
|
return;
|
|
}
|
|
gethostname(hostname, sizeof(hostname));
|
|
|
|
res = isns_do_check(isns, s, hostname);
|
|
if (res < 0) {
|
|
isns_do_deregister(isns, s, hostname);
|
|
isns_do_register(isns, s, hostname);
|
|
}
|
|
close(s);
|
|
set_timeout(0, false);
|
|
}
|
|
|
|
void
|
|
isns_deregister(struct isns *isns)
|
|
{
|
|
struct conf *conf = isns->i_conf;
|
|
int s;
|
|
char hostname[256];
|
|
|
|
if (TAILQ_EMPTY(&conf->conf_targets) ||
|
|
TAILQ_EMPTY(&conf->conf_portal_groups))
|
|
return;
|
|
set_timeout(conf->conf_isns_timeout, false);
|
|
s = isns_do_connect(isns);
|
|
if (s < 0)
|
|
return;
|
|
gethostname(hostname, sizeof(hostname));
|
|
|
|
isns_do_deregister(isns, s, hostname);
|
|
close(s);
|
|
set_timeout(0, false);
|
|
}
|
|
|
|
int
|
|
portal_group_set_filter(struct portal_group *pg, const char *str)
|
|
{
|
|
int filter;
|
|
|
|
if (strcmp(str, "none") == 0) {
|
|
filter = PG_FILTER_NONE;
|
|
} else if (strcmp(str, "portal") == 0) {
|
|
filter = PG_FILTER_PORTAL;
|
|
} else if (strcmp(str, "portal-name") == 0) {
|
|
filter = PG_FILTER_PORTAL_NAME;
|
|
} else if (strcmp(str, "portal-name-auth") == 0) {
|
|
filter = PG_FILTER_PORTAL_NAME_AUTH;
|
|
} else {
|
|
log_warnx("invalid discovery-filter \"%s\" for portal-group "
|
|
"\"%s\"; valid values are \"none\", \"portal\", "
|
|
"\"portal-name\", and \"portal-name-auth\"",
|
|
str, pg->pg_name);
|
|
return (1);
|
|
}
|
|
|
|
if (pg->pg_discovery_filter != PG_FILTER_UNKNOWN &&
|
|
pg->pg_discovery_filter != filter) {
|
|
log_warnx("cannot set discovery-filter to \"%s\" for "
|
|
"portal-group \"%s\"; already has a different "
|
|
"value", str, pg->pg_name);
|
|
return (1);
|
|
}
|
|
|
|
pg->pg_discovery_filter = filter;
|
|
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
portal_group_set_offload(struct portal_group *pg, const char *offload)
|
|
{
|
|
|
|
if (pg->pg_offload != NULL) {
|
|
log_warnx("cannot set offload to \"%s\" for "
|
|
"portal-group \"%s\"; already defined",
|
|
offload, pg->pg_name);
|
|
return (1);
|
|
}
|
|
|
|
pg->pg_offload = checked_strdup(offload);
|
|
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
portal_group_set_redirection(struct portal_group *pg, const char *addr)
|
|
{
|
|
|
|
if (pg->pg_redirection != NULL) {
|
|
log_warnx("cannot set redirection to \"%s\" for "
|
|
"portal-group \"%s\"; already defined",
|
|
addr, pg->pg_name);
|
|
return (1);
|
|
}
|
|
|
|
pg->pg_redirection = checked_strdup(addr);
|
|
|
|
return (0);
|
|
}
|
|
|
|
static bool
|
|
valid_hex(const char ch)
|
|
{
|
|
switch (ch) {
|
|
case '0':
|
|
case '1':
|
|
case '2':
|
|
case '3':
|
|
case '4':
|
|
case '5':
|
|
case '6':
|
|
case '7':
|
|
case '8':
|
|
case '9':
|
|
case 'a':
|
|
case 'A':
|
|
case 'b':
|
|
case 'B':
|
|
case 'c':
|
|
case 'C':
|
|
case 'd':
|
|
case 'D':
|
|
case 'e':
|
|
case 'E':
|
|
case 'f':
|
|
case 'F':
|
|
return (true);
|
|
default:
|
|
return (false);
|
|
}
|
|
}
|
|
|
|
bool
|
|
valid_iscsi_name(const char *name)
|
|
{
|
|
int i;
|
|
|
|
if (strlen(name) >= MAX_NAME_LEN) {
|
|
log_warnx("overlong name for target \"%s\"; max length allowed "
|
|
"by iSCSI specification is %d characters",
|
|
name, MAX_NAME_LEN);
|
|
return (false);
|
|
}
|
|
|
|
/*
|
|
* In the cases below, we don't return an error, just in case the admin
|
|
* was right, and we're wrong.
|
|
*/
|
|
if (strncasecmp(name, "iqn.", strlen("iqn.")) == 0) {
|
|
for (i = strlen("iqn."); name[i] != '\0'; i++) {
|
|
/*
|
|
* XXX: We should verify UTF-8 normalisation, as defined
|
|
* by 3.2.6.2: iSCSI Name Encoding.
|
|
*/
|
|
if (isalnum(name[i]))
|
|
continue;
|
|
if (name[i] == '-' || name[i] == '.' || name[i] == ':')
|
|
continue;
|
|
log_warnx("invalid character \"%c\" in target name "
|
|
"\"%s\"; allowed characters are letters, digits, "
|
|
"'-', '.', and ':'", name[i], name);
|
|
break;
|
|
}
|
|
/*
|
|
* XXX: Check more stuff: valid date and a valid reversed domain.
|
|
*/
|
|
} else if (strncasecmp(name, "eui.", strlen("eui.")) == 0) {
|
|
if (strlen(name) != strlen("eui.") + 16)
|
|
log_warnx("invalid target name \"%s\"; the \"eui.\" "
|
|
"should be followed by exactly 16 hexadecimal "
|
|
"digits", name);
|
|
for (i = strlen("eui."); name[i] != '\0'; i++) {
|
|
if (!valid_hex(name[i])) {
|
|
log_warnx("invalid character \"%c\" in target "
|
|
"name \"%s\"; allowed characters are 1-9 "
|
|
"and A-F", name[i], name);
|
|
break;
|
|
}
|
|
}
|
|
} else if (strncasecmp(name, "naa.", strlen("naa.")) == 0) {
|
|
if (strlen(name) > strlen("naa.") + 32)
|
|
log_warnx("invalid target name \"%s\"; the \"naa.\" "
|
|
"should be followed by at most 32 hexadecimal "
|
|
"digits", name);
|
|
for (i = strlen("naa."); name[i] != '\0'; i++) {
|
|
if (!valid_hex(name[i])) {
|
|
log_warnx("invalid character \"%c\" in target "
|
|
"name \"%s\"; allowed characters are 1-9 "
|
|
"and A-F", name[i], name);
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
log_warnx("invalid target name \"%s\"; should start with "
|
|
"either \"iqn.\", \"eui.\", or \"naa.\"",
|
|
name);
|
|
}
|
|
return (true);
|
|
}
|
|
|
|
struct pport *
|
|
pport_new(struct conf *conf, const char *name, uint32_t ctl_port)
|
|
{
|
|
struct pport *pp;
|
|
|
|
pp = calloc(1, sizeof(*pp));
|
|
if (pp == NULL)
|
|
log_err(1, "calloc");
|
|
pp->pp_conf = conf;
|
|
pp->pp_name = checked_strdup(name);
|
|
pp->pp_ctl_port = ctl_port;
|
|
TAILQ_INIT(&pp->pp_ports);
|
|
TAILQ_INSERT_TAIL(&conf->conf_pports, pp, pp_next);
|
|
return (pp);
|
|
}
|
|
|
|
struct pport *
|
|
pport_find(const struct conf *conf, const char *name)
|
|
{
|
|
struct pport *pp;
|
|
|
|
TAILQ_FOREACH(pp, &conf->conf_pports, pp_next) {
|
|
if (strcasecmp(pp->pp_name, name) == 0)
|
|
return (pp);
|
|
}
|
|
return (NULL);
|
|
}
|
|
|
|
struct pport *
|
|
pport_copy(struct pport *pp, struct conf *conf)
|
|
{
|
|
struct pport *ppnew;
|
|
|
|
ppnew = pport_new(conf, pp->pp_name, pp->pp_ctl_port);
|
|
return (ppnew);
|
|
}
|
|
|
|
void
|
|
pport_delete(struct pport *pp)
|
|
{
|
|
struct port *port, *tport;
|
|
|
|
TAILQ_FOREACH_SAFE(port, &pp->pp_ports, p_ts, tport)
|
|
port_delete(port);
|
|
TAILQ_REMOVE(&pp->pp_conf->conf_pports, pp, pp_next);
|
|
free(pp->pp_name);
|
|
free(pp);
|
|
}
|
|
|
|
struct port *
|
|
port_new(struct conf *conf, struct target *target, struct portal_group *pg)
|
|
{
|
|
struct port *port;
|
|
char *name;
|
|
int ret;
|
|
|
|
ret = asprintf(&name, "%s-%s", pg->pg_name, target->t_name);
|
|
if (ret <= 0)
|
|
log_err(1, "asprintf");
|
|
if (port_find(conf, name) != NULL) {
|
|
log_warnx("duplicate port \"%s\"", name);
|
|
free(name);
|
|
return (NULL);
|
|
}
|
|
port = calloc(1, sizeof(*port));
|
|
if (port == NULL)
|
|
log_err(1, "calloc");
|
|
port->p_conf = conf;
|
|
port->p_name = name;
|
|
TAILQ_INSERT_TAIL(&conf->conf_ports, port, p_next);
|
|
TAILQ_INSERT_TAIL(&target->t_ports, port, p_ts);
|
|
port->p_target = target;
|
|
TAILQ_INSERT_TAIL(&pg->pg_ports, port, p_pgs);
|
|
port->p_portal_group = pg;
|
|
port->p_foreign = pg->pg_foreign;
|
|
return (port);
|
|
}
|
|
|
|
struct port *
|
|
port_new_pp(struct conf *conf, struct target *target, struct pport *pp)
|
|
{
|
|
struct port *port;
|
|
char *name;
|
|
int ret;
|
|
|
|
ret = asprintf(&name, "%s-%s", pp->pp_name, target->t_name);
|
|
if (ret <= 0)
|
|
log_err(1, "asprintf");
|
|
if (port_find(conf, name) != NULL) {
|
|
log_warnx("duplicate port \"%s\"", name);
|
|
free(name);
|
|
return (NULL);
|
|
}
|
|
port = calloc(1, sizeof(*port));
|
|
if (port == NULL)
|
|
log_err(1, "calloc");
|
|
port->p_conf = conf;
|
|
port->p_name = name;
|
|
TAILQ_INSERT_TAIL(&conf->conf_ports, port, p_next);
|
|
TAILQ_INSERT_TAIL(&target->t_ports, port, p_ts);
|
|
port->p_target = target;
|
|
TAILQ_INSERT_TAIL(&pp->pp_ports, port, p_pps);
|
|
port->p_pport = pp;
|
|
return (port);
|
|
}
|
|
|
|
struct port *
|
|
port_find(const struct conf *conf, const char *name)
|
|
{
|
|
struct port *port;
|
|
|
|
TAILQ_FOREACH(port, &conf->conf_ports, p_next) {
|
|
if (strcasecmp(port->p_name, name) == 0)
|
|
return (port);
|
|
}
|
|
|
|
return (NULL);
|
|
}
|
|
|
|
struct port *
|
|
port_find_in_pg(const struct portal_group *pg, const char *target)
|
|
{
|
|
struct port *port;
|
|
|
|
TAILQ_FOREACH(port, &pg->pg_ports, p_pgs) {
|
|
if (strcasecmp(port->p_target->t_name, target) == 0)
|
|
return (port);
|
|
}
|
|
|
|
return (NULL);
|
|
}
|
|
|
|
void
|
|
port_delete(struct port *port)
|
|
{
|
|
|
|
if (port->p_portal_group)
|
|
TAILQ_REMOVE(&port->p_portal_group->pg_ports, port, p_pgs);
|
|
if (port->p_pport)
|
|
TAILQ_REMOVE(&port->p_pport->pp_ports, port, p_pps);
|
|
if (port->p_target)
|
|
TAILQ_REMOVE(&port->p_target->t_ports, port, p_ts);
|
|
TAILQ_REMOVE(&port->p_conf->conf_ports, port, p_next);
|
|
free(port->p_name);
|
|
free(port);
|
|
}
|
|
|
|
struct target *
|
|
target_new(struct conf *conf, const char *name)
|
|
{
|
|
struct target *targ;
|
|
int i, len;
|
|
|
|
targ = target_find(conf, name);
|
|
if (targ != NULL) {
|
|
log_warnx("duplicated target \"%s\"", name);
|
|
return (NULL);
|
|
}
|
|
if (valid_iscsi_name(name) == false) {
|
|
log_warnx("target name \"%s\" is invalid", name);
|
|
return (NULL);
|
|
}
|
|
targ = calloc(1, sizeof(*targ));
|
|
if (targ == NULL)
|
|
log_err(1, "calloc");
|
|
targ->t_name = checked_strdup(name);
|
|
|
|
/*
|
|
* RFC 3722 requires us to normalize the name to lowercase.
|
|
*/
|
|
len = strlen(name);
|
|
for (i = 0; i < len; i++)
|
|
targ->t_name[i] = tolower(targ->t_name[i]);
|
|
|
|
targ->t_conf = conf;
|
|
TAILQ_INIT(&targ->t_ports);
|
|
TAILQ_INSERT_TAIL(&conf->conf_targets, targ, t_next);
|
|
|
|
return (targ);
|
|
}
|
|
|
|
void
|
|
target_delete(struct target *targ)
|
|
{
|
|
struct port *port, *tport;
|
|
|
|
TAILQ_FOREACH_SAFE(port, &targ->t_ports, p_ts, tport)
|
|
port_delete(port);
|
|
TAILQ_REMOVE(&targ->t_conf->conf_targets, targ, t_next);
|
|
|
|
free(targ->t_name);
|
|
free(targ->t_redirection);
|
|
free(targ);
|
|
}
|
|
|
|
struct target *
|
|
target_find(struct conf *conf, const char *name)
|
|
{
|
|
struct target *targ;
|
|
|
|
TAILQ_FOREACH(targ, &conf->conf_targets, t_next) {
|
|
if (strcasecmp(targ->t_name, name) == 0)
|
|
return (targ);
|
|
}
|
|
|
|
return (NULL);
|
|
}
|
|
|
|
int
|
|
target_set_redirection(struct target *target, const char *addr)
|
|
{
|
|
|
|
if (target->t_redirection != NULL) {
|
|
log_warnx("cannot set redirection to \"%s\" for "
|
|
"target \"%s\"; already defined",
|
|
addr, target->t_name);
|
|
return (1);
|
|
}
|
|
|
|
target->t_redirection = checked_strdup(addr);
|
|
|
|
return (0);
|
|
}
|
|
|
|
struct lun *
|
|
lun_new(struct conf *conf, const char *name)
|
|
{
|
|
struct lun *lun;
|
|
|
|
lun = lun_find(conf, name);
|
|
if (lun != NULL) {
|
|
log_warnx("duplicated lun \"%s\"", name);
|
|
return (NULL);
|
|
}
|
|
|
|
lun = calloc(1, sizeof(*lun));
|
|
if (lun == NULL)
|
|
log_err(1, "calloc");
|
|
lun->l_conf = conf;
|
|
lun->l_name = checked_strdup(name);
|
|
TAILQ_INIT(&lun->l_options);
|
|
TAILQ_INSERT_TAIL(&conf->conf_luns, lun, l_next);
|
|
lun->l_ctl_lun = -1;
|
|
|
|
return (lun);
|
|
}
|
|
|
|
void
|
|
lun_delete(struct lun *lun)
|
|
{
|
|
struct target *targ;
|
|
struct option *o, *tmp;
|
|
int i;
|
|
|
|
TAILQ_FOREACH(targ, &lun->l_conf->conf_targets, t_next) {
|
|
for (i = 0; i < MAX_LUNS; i++) {
|
|
if (targ->t_luns[i] == lun)
|
|
targ->t_luns[i] = NULL;
|
|
}
|
|
}
|
|
TAILQ_REMOVE(&lun->l_conf->conf_luns, lun, l_next);
|
|
|
|
TAILQ_FOREACH_SAFE(o, &lun->l_options, o_next, tmp)
|
|
option_delete(&lun->l_options, o);
|
|
free(lun->l_name);
|
|
free(lun->l_backend);
|
|
free(lun->l_device_id);
|
|
free(lun->l_path);
|
|
free(lun->l_scsiname);
|
|
free(lun->l_serial);
|
|
free(lun);
|
|
}
|
|
|
|
struct lun *
|
|
lun_find(const struct conf *conf, const char *name)
|
|
{
|
|
struct lun *lun;
|
|
|
|
TAILQ_FOREACH(lun, &conf->conf_luns, l_next) {
|
|
if (strcmp(lun->l_name, name) == 0)
|
|
return (lun);
|
|
}
|
|
|
|
return (NULL);
|
|
}
|
|
|
|
void
|
|
lun_set_backend(struct lun *lun, const char *value)
|
|
{
|
|
free(lun->l_backend);
|
|
lun->l_backend = checked_strdup(value);
|
|
}
|
|
|
|
void
|
|
lun_set_blocksize(struct lun *lun, size_t value)
|
|
{
|
|
|
|
lun->l_blocksize = value;
|
|
}
|
|
|
|
void
|
|
lun_set_device_type(struct lun *lun, uint8_t value)
|
|
{
|
|
|
|
lun->l_device_type = value;
|
|
}
|
|
|
|
void
|
|
lun_set_device_id(struct lun *lun, const char *value)
|
|
{
|
|
free(lun->l_device_id);
|
|
lun->l_device_id = checked_strdup(value);
|
|
}
|
|
|
|
void
|
|
lun_set_path(struct lun *lun, const char *value)
|
|
{
|
|
free(lun->l_path);
|
|
lun->l_path = checked_strdup(value);
|
|
}
|
|
|
|
void
|
|
lun_set_scsiname(struct lun *lun, const char *value)
|
|
{
|
|
free(lun->l_scsiname);
|
|
lun->l_scsiname = checked_strdup(value);
|
|
}
|
|
|
|
void
|
|
lun_set_serial(struct lun *lun, const char *value)
|
|
{
|
|
free(lun->l_serial);
|
|
lun->l_serial = checked_strdup(value);
|
|
}
|
|
|
|
void
|
|
lun_set_size(struct lun *lun, size_t value)
|
|
{
|
|
|
|
lun->l_size = value;
|
|
}
|
|
|
|
void
|
|
lun_set_ctl_lun(struct lun *lun, uint32_t value)
|
|
{
|
|
|
|
lun->l_ctl_lun = value;
|
|
}
|
|
|
|
struct option *
|
|
option_new(struct options *options, const char *name, const char *value)
|
|
{
|
|
struct option *o;
|
|
|
|
o = option_find(options, name);
|
|
if (o != NULL) {
|
|
log_warnx("duplicated option \"%s\"", name);
|
|
return (NULL);
|
|
}
|
|
|
|
o = calloc(1, sizeof(*o));
|
|
if (o == NULL)
|
|
log_err(1, "calloc");
|
|
o->o_name = checked_strdup(name);
|
|
o->o_value = checked_strdup(value);
|
|
TAILQ_INSERT_TAIL(options, o, o_next);
|
|
|
|
return (o);
|
|
}
|
|
|
|
void
|
|
option_delete(struct options *options, struct option *o)
|
|
{
|
|
|
|
TAILQ_REMOVE(options, o, o_next);
|
|
free(o->o_name);
|
|
free(o->o_value);
|
|
free(o);
|
|
}
|
|
|
|
struct option *
|
|
option_find(const struct options *options, const char *name)
|
|
{
|
|
struct option *o;
|
|
|
|
TAILQ_FOREACH(o, options, o_next) {
|
|
if (strcmp(o->o_name, name) == 0)
|
|
return (o);
|
|
}
|
|
|
|
return (NULL);
|
|
}
|
|
|
|
void
|
|
option_set(struct option *o, const char *value)
|
|
{
|
|
|
|
free(o->o_value);
|
|
o->o_value = checked_strdup(value);
|
|
}
|
|
|
|
static struct connection *
|
|
connection_new(struct portal *portal, int fd, const char *host,
|
|
const struct sockaddr *client_sa)
|
|
{
|
|
struct connection *conn;
|
|
|
|
conn = calloc(1, sizeof(*conn));
|
|
if (conn == NULL)
|
|
log_err(1, "calloc");
|
|
conn->conn_portal = portal;
|
|
conn->conn_socket = fd;
|
|
conn->conn_initiator_addr = checked_strdup(host);
|
|
memcpy(&conn->conn_initiator_sa, client_sa, client_sa->sa_len);
|
|
|
|
/*
|
|
* Default values, from RFC 3720, section 12.
|
|
*/
|
|
conn->conn_max_recv_data_segment_length = 8192;
|
|
conn->conn_max_burst_length = 262144;
|
|
conn->conn_first_burst_length = 65536;
|
|
conn->conn_immediate_data = true;
|
|
|
|
return (conn);
|
|
}
|
|
|
|
#if 0
|
|
static void
|
|
conf_print(struct conf *conf)
|
|
{
|
|
struct auth_group *ag;
|
|
struct auth *auth;
|
|
struct auth_name *auth_name;
|
|
struct auth_portal *auth_portal;
|
|
struct portal_group *pg;
|
|
struct portal *portal;
|
|
struct target *targ;
|
|
struct lun *lun;
|
|
struct option *o;
|
|
|
|
TAILQ_FOREACH(ag, &conf->conf_auth_groups, ag_next) {
|
|
fprintf(stderr, "auth-group %s {\n", ag->ag_name);
|
|
TAILQ_FOREACH(auth, &ag->ag_auths, a_next)
|
|
fprintf(stderr, "\t chap-mutual %s %s %s %s\n",
|
|
auth->a_user, auth->a_secret,
|
|
auth->a_mutual_user, auth->a_mutual_secret);
|
|
TAILQ_FOREACH(auth_name, &ag->ag_names, an_next)
|
|
fprintf(stderr, "\t initiator-name %s\n",
|
|
auth_name->an_initator_name);
|
|
TAILQ_FOREACH(auth_portal, &ag->ag_portals, an_next)
|
|
fprintf(stderr, "\t initiator-portal %s\n",
|
|
auth_portal->an_initator_portal);
|
|
fprintf(stderr, "}\n");
|
|
}
|
|
TAILQ_FOREACH(pg, &conf->conf_portal_groups, pg_next) {
|
|
fprintf(stderr, "portal-group %s {\n", pg->pg_name);
|
|
TAILQ_FOREACH(portal, &pg->pg_portals, p_next)
|
|
fprintf(stderr, "\t listen %s\n", portal->p_listen);
|
|
fprintf(stderr, "}\n");
|
|
}
|
|
TAILQ_FOREACH(lun, &conf->conf_luns, l_next) {
|
|
fprintf(stderr, "\tlun %s {\n", lun->l_name);
|
|
fprintf(stderr, "\t\tpath %s\n", lun->l_path);
|
|
TAILQ_FOREACH(o, &lun->l_options, o_next)
|
|
fprintf(stderr, "\t\toption %s %s\n",
|
|
lo->o_name, lo->o_value);
|
|
fprintf(stderr, "\t}\n");
|
|
}
|
|
TAILQ_FOREACH(targ, &conf->conf_targets, t_next) {
|
|
fprintf(stderr, "target %s {\n", targ->t_name);
|
|
if (targ->t_alias != NULL)
|
|
fprintf(stderr, "\t alias %s\n", targ->t_alias);
|
|
fprintf(stderr, "}\n");
|
|
}
|
|
}
|
|
#endif
|
|
|
|
static int
|
|
conf_verify_lun(struct lun *lun)
|
|
{
|
|
const struct lun *lun2;
|
|
|
|
if (lun->l_backend == NULL)
|
|
lun_set_backend(lun, "block");
|
|
if (strcmp(lun->l_backend, "block") == 0) {
|
|
if (lun->l_path == NULL) {
|
|
log_warnx("missing path for lun \"%s\"",
|
|
lun->l_name);
|
|
return (1);
|
|
}
|
|
} else if (strcmp(lun->l_backend, "ramdisk") == 0) {
|
|
if (lun->l_size == 0) {
|
|
log_warnx("missing size for ramdisk-backed lun \"%s\"",
|
|
lun->l_name);
|
|
return (1);
|
|
}
|
|
if (lun->l_path != NULL) {
|
|
log_warnx("path must not be specified "
|
|
"for ramdisk-backed lun \"%s\"",
|
|
lun->l_name);
|
|
return (1);
|
|
}
|
|
}
|
|
if (lun->l_blocksize == 0) {
|
|
if (lun->l_device_type == 5)
|
|
lun_set_blocksize(lun, DEFAULT_CD_BLOCKSIZE);
|
|
else
|
|
lun_set_blocksize(lun, DEFAULT_BLOCKSIZE);
|
|
} else if (lun->l_blocksize < 0) {
|
|
log_warnx("invalid blocksize for lun \"%s\"; "
|
|
"must be larger than 0", lun->l_name);
|
|
return (1);
|
|
}
|
|
if (lun->l_size != 0 && lun->l_size % lun->l_blocksize != 0) {
|
|
log_warnx("invalid size for lun \"%s\"; "
|
|
"must be multiple of blocksize", lun->l_name);
|
|
return (1);
|
|
}
|
|
TAILQ_FOREACH(lun2, &lun->l_conf->conf_luns, l_next) {
|
|
if (lun == lun2)
|
|
continue;
|
|
if (lun->l_path != NULL && lun2->l_path != NULL &&
|
|
strcmp(lun->l_path, lun2->l_path) == 0) {
|
|
log_debugx("WARNING: path \"%s\" duplicated "
|
|
"between lun \"%s\", and "
|
|
"lun \"%s\"", lun->l_path,
|
|
lun->l_name, lun2->l_name);
|
|
}
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
conf_verify(struct conf *conf)
|
|
{
|
|
struct auth_group *ag;
|
|
struct portal_group *pg;
|
|
struct port *port;
|
|
struct target *targ;
|
|
struct lun *lun;
|
|
bool found;
|
|
int error, i;
|
|
|
|
if (conf->conf_pidfile_path == NULL)
|
|
conf->conf_pidfile_path = checked_strdup(DEFAULT_PIDFILE);
|
|
|
|
TAILQ_FOREACH(lun, &conf->conf_luns, l_next) {
|
|
error = conf_verify_lun(lun);
|
|
if (error != 0)
|
|
return (error);
|
|
}
|
|
TAILQ_FOREACH(targ, &conf->conf_targets, t_next) {
|
|
if (targ->t_auth_group == NULL) {
|
|
targ->t_auth_group = auth_group_find(conf,
|
|
"default");
|
|
assert(targ->t_auth_group != NULL);
|
|
}
|
|
if (TAILQ_EMPTY(&targ->t_ports)) {
|
|
pg = portal_group_find(conf, "default");
|
|
assert(pg != NULL);
|
|
port_new(conf, targ, pg);
|
|
}
|
|
found = false;
|
|
for (i = 0; i < MAX_LUNS; i++) {
|
|
if (targ->t_luns[i] != NULL)
|
|
found = true;
|
|
}
|
|
if (!found && targ->t_redirection == NULL) {
|
|
log_warnx("no LUNs defined for target \"%s\"",
|
|
targ->t_name);
|
|
}
|
|
if (found && targ->t_redirection != NULL) {
|
|
log_debugx("target \"%s\" contains luns, "
|
|
" but configured for redirection",
|
|
targ->t_name);
|
|
}
|
|
}
|
|
TAILQ_FOREACH(pg, &conf->conf_portal_groups, pg_next) {
|
|
assert(pg->pg_name != NULL);
|
|
if (pg->pg_discovery_auth_group == NULL) {
|
|
pg->pg_discovery_auth_group =
|
|
auth_group_find(conf, "default");
|
|
assert(pg->pg_discovery_auth_group != NULL);
|
|
}
|
|
|
|
if (pg->pg_discovery_filter == PG_FILTER_UNKNOWN)
|
|
pg->pg_discovery_filter = PG_FILTER_NONE;
|
|
|
|
if (pg->pg_redirection != NULL) {
|
|
if (!TAILQ_EMPTY(&pg->pg_ports)) {
|
|
log_debugx("portal-group \"%s\" assigned "
|
|
"to target, but configured "
|
|
"for redirection",
|
|
pg->pg_name);
|
|
}
|
|
pg->pg_unassigned = false;
|
|
} else if (!TAILQ_EMPTY(&pg->pg_ports)) {
|
|
pg->pg_unassigned = false;
|
|
} else {
|
|
if (strcmp(pg->pg_name, "default") != 0)
|
|
log_warnx("portal-group \"%s\" not assigned "
|
|
"to any target", pg->pg_name);
|
|
pg->pg_unassigned = true;
|
|
}
|
|
}
|
|
TAILQ_FOREACH(ag, &conf->conf_auth_groups, ag_next) {
|
|
if (ag->ag_name == NULL)
|
|
assert(ag->ag_target != NULL);
|
|
else
|
|
assert(ag->ag_target == NULL);
|
|
|
|
found = false;
|
|
TAILQ_FOREACH(targ, &conf->conf_targets, t_next) {
|
|
if (targ->t_auth_group == ag) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
TAILQ_FOREACH(port, &conf->conf_ports, p_next) {
|
|
if (port->p_auth_group == ag) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
TAILQ_FOREACH(pg, &conf->conf_portal_groups, pg_next) {
|
|
if (pg->pg_discovery_auth_group == ag) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!found && ag->ag_name != NULL &&
|
|
strcmp(ag->ag_name, "default") != 0 &&
|
|
strcmp(ag->ag_name, "no-authentication") != 0 &&
|
|
strcmp(ag->ag_name, "no-access") != 0) {
|
|
log_warnx("auth-group \"%s\" not assigned "
|
|
"to any target", ag->ag_name);
|
|
}
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
static int
|
|
conf_apply(struct conf *oldconf, struct conf *newconf)
|
|
{
|
|
struct lun *oldlun, *newlun, *tmplun;
|
|
struct portal_group *oldpg, *newpg;
|
|
struct portal *oldp, *newp;
|
|
struct port *oldport, *newport, *tmpport;
|
|
struct isns *oldns, *newns;
|
|
pid_t otherpid;
|
|
int changed, cumulated_error = 0, error, sockbuf;
|
|
int one = 1;
|
|
|
|
if (oldconf->conf_debug != newconf->conf_debug) {
|
|
log_debugx("changing debug level to %d", newconf->conf_debug);
|
|
log_init(newconf->conf_debug);
|
|
}
|
|
|
|
if (oldconf->conf_pidfh != NULL) {
|
|
assert(oldconf->conf_pidfile_path != NULL);
|
|
if (newconf->conf_pidfile_path != NULL &&
|
|
strcmp(oldconf->conf_pidfile_path,
|
|
newconf->conf_pidfile_path) == 0) {
|
|
newconf->conf_pidfh = oldconf->conf_pidfh;
|
|
oldconf->conf_pidfh = NULL;
|
|
} else {
|
|
log_debugx("removing pidfile %s",
|
|
oldconf->conf_pidfile_path);
|
|
pidfile_remove(oldconf->conf_pidfh);
|
|
oldconf->conf_pidfh = NULL;
|
|
}
|
|
}
|
|
|
|
if (newconf->conf_pidfh == NULL && newconf->conf_pidfile_path != NULL) {
|
|
log_debugx("opening pidfile %s", newconf->conf_pidfile_path);
|
|
newconf->conf_pidfh =
|
|
pidfile_open(newconf->conf_pidfile_path, 0600, &otherpid);
|
|
if (newconf->conf_pidfh == NULL) {
|
|
if (errno == EEXIST)
|
|
log_errx(1, "daemon already running, pid: %jd.",
|
|
(intmax_t)otherpid);
|
|
log_err(1, "cannot open or create pidfile \"%s\"",
|
|
newconf->conf_pidfile_path);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Go through the new portal groups, assigning tags or preserving old.
|
|
*/
|
|
TAILQ_FOREACH(newpg, &newconf->conf_portal_groups, pg_next) {
|
|
if (newpg->pg_tag != 0)
|
|
continue;
|
|
oldpg = portal_group_find(oldconf, newpg->pg_name);
|
|
if (oldpg != NULL)
|
|
newpg->pg_tag = oldpg->pg_tag;
|
|
else
|
|
newpg->pg_tag = ++last_portal_group_tag;
|
|
}
|
|
|
|
/* Deregister on removed iSNS servers. */
|
|
TAILQ_FOREACH(oldns, &oldconf->conf_isns, i_next) {
|
|
TAILQ_FOREACH(newns, &newconf->conf_isns, i_next) {
|
|
if (strcmp(oldns->i_addr, newns->i_addr) == 0)
|
|
break;
|
|
}
|
|
if (newns == NULL)
|
|
isns_deregister(oldns);
|
|
}
|
|
|
|
/*
|
|
* XXX: If target or lun removal fails, we should somehow "move"
|
|
* the old lun or target into newconf, so that subsequent
|
|
* conf_apply() would try to remove them again. That would
|
|
* be somewhat hairy, though, and lun deletion failures don't
|
|
* really happen, so leave it as it is for now.
|
|
*/
|
|
/*
|
|
* First, remove any ports present in the old configuration
|
|
* and missing in the new one.
|
|
*/
|
|
TAILQ_FOREACH_SAFE(oldport, &oldconf->conf_ports, p_next, tmpport) {
|
|
if (oldport->p_foreign)
|
|
continue;
|
|
newport = port_find(newconf, oldport->p_name);
|
|
if (newport != NULL && !newport->p_foreign)
|
|
continue;
|
|
log_debugx("removing port \"%s\"", oldport->p_name);
|
|
error = kernel_port_remove(oldport);
|
|
if (error != 0) {
|
|
log_warnx("failed to remove port %s",
|
|
oldport->p_name);
|
|
/*
|
|
* XXX: Uncomment after fixing the root cause.
|
|
*
|
|
* cumulated_error++;
|
|
*/
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Second, remove any LUNs present in the old configuration
|
|
* and missing in the new one.
|
|
*/
|
|
TAILQ_FOREACH_SAFE(oldlun, &oldconf->conf_luns, l_next, tmplun) {
|
|
newlun = lun_find(newconf, oldlun->l_name);
|
|
if (newlun == NULL) {
|
|
log_debugx("lun \"%s\", CTL lun %d "
|
|
"not found in new configuration; "
|
|
"removing", oldlun->l_name, oldlun->l_ctl_lun);
|
|
error = kernel_lun_remove(oldlun);
|
|
if (error != 0) {
|
|
log_warnx("failed to remove lun \"%s\", "
|
|
"CTL lun %d",
|
|
oldlun->l_name, oldlun->l_ctl_lun);
|
|
cumulated_error++;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
/*
|
|
* Also remove the LUNs changed by more than size.
|
|
*/
|
|
changed = 0;
|
|
assert(oldlun->l_backend != NULL);
|
|
assert(newlun->l_backend != NULL);
|
|
if (strcmp(newlun->l_backend, oldlun->l_backend) != 0) {
|
|
log_debugx("backend for lun \"%s\", "
|
|
"CTL lun %d changed; removing",
|
|
oldlun->l_name, oldlun->l_ctl_lun);
|
|
changed = 1;
|
|
}
|
|
if (oldlun->l_blocksize != newlun->l_blocksize) {
|
|
log_debugx("blocksize for lun \"%s\", "
|
|
"CTL lun %d changed; removing",
|
|
oldlun->l_name, oldlun->l_ctl_lun);
|
|
changed = 1;
|
|
}
|
|
if (newlun->l_device_id != NULL &&
|
|
(oldlun->l_device_id == NULL ||
|
|
strcmp(oldlun->l_device_id, newlun->l_device_id) !=
|
|
0)) {
|
|
log_debugx("device-id for lun \"%s\", "
|
|
"CTL lun %d changed; removing",
|
|
oldlun->l_name, oldlun->l_ctl_lun);
|
|
changed = 1;
|
|
}
|
|
if (newlun->l_path != NULL &&
|
|
(oldlun->l_path == NULL ||
|
|
strcmp(oldlun->l_path, newlun->l_path) != 0)) {
|
|
log_debugx("path for lun \"%s\", "
|
|
"CTL lun %d, changed; removing",
|
|
oldlun->l_name, oldlun->l_ctl_lun);
|
|
changed = 1;
|
|
}
|
|
if (newlun->l_serial != NULL &&
|
|
(oldlun->l_serial == NULL ||
|
|
strcmp(oldlun->l_serial, newlun->l_serial) != 0)) {
|
|
log_debugx("serial for lun \"%s\", "
|
|
"CTL lun %d changed; removing",
|
|
oldlun->l_name, oldlun->l_ctl_lun);
|
|
changed = 1;
|
|
}
|
|
if (changed) {
|
|
error = kernel_lun_remove(oldlun);
|
|
if (error != 0) {
|
|
log_warnx("failed to remove lun \"%s\", "
|
|
"CTL lun %d",
|
|
oldlun->l_name, oldlun->l_ctl_lun);
|
|
cumulated_error++;
|
|
}
|
|
lun_delete(oldlun);
|
|
continue;
|
|
}
|
|
|
|
lun_set_ctl_lun(newlun, oldlun->l_ctl_lun);
|
|
}
|
|
|
|
TAILQ_FOREACH_SAFE(newlun, &newconf->conf_luns, l_next, tmplun) {
|
|
oldlun = lun_find(oldconf, newlun->l_name);
|
|
if (oldlun != NULL) {
|
|
log_debugx("modifying lun \"%s\", CTL lun %d",
|
|
newlun->l_name, newlun->l_ctl_lun);
|
|
error = kernel_lun_modify(newlun);
|
|
if (error != 0) {
|
|
log_warnx("failed to "
|
|
"modify lun \"%s\", CTL lun %d",
|
|
newlun->l_name, newlun->l_ctl_lun);
|
|
cumulated_error++;
|
|
}
|
|
continue;
|
|
}
|
|
log_debugx("adding lun \"%s\"", newlun->l_name);
|
|
error = kernel_lun_add(newlun);
|
|
if (error != 0) {
|
|
log_warnx("failed to add lun \"%s\"", newlun->l_name);
|
|
lun_delete(newlun);
|
|
cumulated_error++;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Now add new ports or modify existing ones.
|
|
*/
|
|
TAILQ_FOREACH(newport, &newconf->conf_ports, p_next) {
|
|
if (newport->p_foreign)
|
|
continue;
|
|
oldport = port_find(oldconf, newport->p_name);
|
|
|
|
if (oldport == NULL || oldport->p_foreign) {
|
|
log_debugx("adding port \"%s\"", newport->p_name);
|
|
error = kernel_port_add(newport);
|
|
} else {
|
|
log_debugx("updating port \"%s\"", newport->p_name);
|
|
newport->p_ctl_port = oldport->p_ctl_port;
|
|
error = kernel_port_update(newport, oldport);
|
|
}
|
|
if (error != 0) {
|
|
log_warnx("failed to %s port %s",
|
|
(oldport == NULL) ? "add" : "update",
|
|
newport->p_name);
|
|
/*
|
|
* XXX: Uncomment after fixing the root cause.
|
|
*
|
|
* cumulated_error++;
|
|
*/
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Go through the new portals, opening the sockets as necessary.
|
|
*/
|
|
TAILQ_FOREACH(newpg, &newconf->conf_portal_groups, pg_next) {
|
|
if (newpg->pg_foreign)
|
|
continue;
|
|
if (newpg->pg_unassigned) {
|
|
log_debugx("not listening on portal-group \"%s\", "
|
|
"not assigned to any target",
|
|
newpg->pg_name);
|
|
continue;
|
|
}
|
|
TAILQ_FOREACH(newp, &newpg->pg_portals, p_next) {
|
|
/*
|
|
* Try to find already open portal and reuse
|
|
* the listening socket. We don't care about
|
|
* what portal or portal group that was, what
|
|
* matters is the listening address.
|
|
*/
|
|
TAILQ_FOREACH(oldpg, &oldconf->conf_portal_groups,
|
|
pg_next) {
|
|
TAILQ_FOREACH(oldp, &oldpg->pg_portals,
|
|
p_next) {
|
|
if (strcmp(newp->p_listen,
|
|
oldp->p_listen) == 0 &&
|
|
oldp->p_socket > 0) {
|
|
newp->p_socket =
|
|
oldp->p_socket;
|
|
oldp->p_socket = 0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (newp->p_socket > 0) {
|
|
/*
|
|
* We're done with this portal.
|
|
*/
|
|
continue;
|
|
}
|
|
|
|
#ifdef ICL_KERNEL_PROXY
|
|
if (proxy_mode) {
|
|
newpg->pg_conf->conf_portal_id++;
|
|
newp->p_id = newpg->pg_conf->conf_portal_id;
|
|
log_debugx("listening on %s, portal-group "
|
|
"\"%s\", portal id %d, using ICL proxy",
|
|
newp->p_listen, newpg->pg_name, newp->p_id);
|
|
kernel_listen(newp->p_ai, newp->p_iser,
|
|
newp->p_id);
|
|
continue;
|
|
}
|
|
#endif
|
|
assert(proxy_mode == false);
|
|
assert(newp->p_iser == false);
|
|
|
|
log_debugx("listening on %s, portal-group \"%s\"",
|
|
newp->p_listen, newpg->pg_name);
|
|
newp->p_socket = socket(newp->p_ai->ai_family,
|
|
newp->p_ai->ai_socktype,
|
|
newp->p_ai->ai_protocol);
|
|
if (newp->p_socket < 0) {
|
|
log_warn("socket(2) failed for %s",
|
|
newp->p_listen);
|
|
cumulated_error++;
|
|
continue;
|
|
}
|
|
sockbuf = SOCKBUF_SIZE;
|
|
if (setsockopt(newp->p_socket, SOL_SOCKET, SO_RCVBUF,
|
|
&sockbuf, sizeof(sockbuf)) == -1)
|
|
log_warn("setsockopt(SO_RCVBUF) failed "
|
|
"for %s", newp->p_listen);
|
|
sockbuf = SOCKBUF_SIZE;
|
|
if (setsockopt(newp->p_socket, SOL_SOCKET, SO_SNDBUF,
|
|
&sockbuf, sizeof(sockbuf)) == -1)
|
|
log_warn("setsockopt(SO_SNDBUF) failed "
|
|
"for %s", newp->p_listen);
|
|
error = setsockopt(newp->p_socket, SOL_SOCKET,
|
|
SO_REUSEADDR, &one, sizeof(one));
|
|
if (error != 0) {
|
|
log_warn("setsockopt(SO_REUSEADDR) failed "
|
|
"for %s", newp->p_listen);
|
|
close(newp->p_socket);
|
|
newp->p_socket = 0;
|
|
cumulated_error++;
|
|
continue;
|
|
}
|
|
error = bind(newp->p_socket, newp->p_ai->ai_addr,
|
|
newp->p_ai->ai_addrlen);
|
|
if (error != 0) {
|
|
log_warn("bind(2) failed for %s",
|
|
newp->p_listen);
|
|
close(newp->p_socket);
|
|
newp->p_socket = 0;
|
|
cumulated_error++;
|
|
continue;
|
|
}
|
|
error = listen(newp->p_socket, -1);
|
|
if (error != 0) {
|
|
log_warn("listen(2) failed for %s",
|
|
newp->p_listen);
|
|
close(newp->p_socket);
|
|
newp->p_socket = 0;
|
|
cumulated_error++;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Go through the no longer used sockets, closing them.
|
|
*/
|
|
TAILQ_FOREACH(oldpg, &oldconf->conf_portal_groups, pg_next) {
|
|
TAILQ_FOREACH(oldp, &oldpg->pg_portals, p_next) {
|
|
if (oldp->p_socket <= 0)
|
|
continue;
|
|
log_debugx("closing socket for %s, portal-group \"%s\"",
|
|
oldp->p_listen, oldpg->pg_name);
|
|
close(oldp->p_socket);
|
|
oldp->p_socket = 0;
|
|
}
|
|
}
|
|
|
|
/* (Re-)Register on remaining/new iSNS servers. */
|
|
TAILQ_FOREACH(newns, &newconf->conf_isns, i_next) {
|
|
TAILQ_FOREACH(oldns, &oldconf->conf_isns, i_next) {
|
|
if (strcmp(oldns->i_addr, newns->i_addr) == 0)
|
|
break;
|
|
}
|
|
isns_register(newns, oldns);
|
|
}
|
|
|
|
/* Schedule iSNS update */
|
|
if (!TAILQ_EMPTY(&newconf->conf_isns))
|
|
set_timeout((newconf->conf_isns_period + 2) / 3, false);
|
|
|
|
return (cumulated_error);
|
|
}
|
|
|
|
bool
|
|
timed_out(void)
|
|
{
|
|
|
|
return (sigalrm_received);
|
|
}
|
|
|
|
static void
|
|
sigalrm_handler_fatal(int dummy __unused)
|
|
{
|
|
/*
|
|
* It would be easiest to just log an error and exit. We can't
|
|
* do this, though, because log_errx() is not signal safe, since
|
|
* it calls syslog(3). Instead, set a flag checked by pdu_send()
|
|
* and pdu_receive(), to call log_errx() there. Should they fail
|
|
* to notice, we'll exit here one second later.
|
|
*/
|
|
if (sigalrm_received) {
|
|
/*
|
|
* Oh well. Just give up and quit.
|
|
*/
|
|
_exit(2);
|
|
}
|
|
|
|
sigalrm_received = true;
|
|
}
|
|
|
|
static void
|
|
sigalrm_handler(int dummy __unused)
|
|
{
|
|
|
|
sigalrm_received = true;
|
|
}
|
|
|
|
void
|
|
set_timeout(int timeout, int fatal)
|
|
{
|
|
struct sigaction sa;
|
|
struct itimerval itv;
|
|
int error;
|
|
|
|
if (timeout <= 0) {
|
|
log_debugx("session timeout disabled");
|
|
bzero(&itv, sizeof(itv));
|
|
error = setitimer(ITIMER_REAL, &itv, NULL);
|
|
if (error != 0)
|
|
log_err(1, "setitimer");
|
|
sigalrm_received = false;
|
|
return;
|
|
}
|
|
|
|
sigalrm_received = false;
|
|
bzero(&sa, sizeof(sa));
|
|
if (fatal)
|
|
sa.sa_handler = sigalrm_handler_fatal;
|
|
else
|
|
sa.sa_handler = sigalrm_handler;
|
|
sigfillset(&sa.sa_mask);
|
|
error = sigaction(SIGALRM, &sa, NULL);
|
|
if (error != 0)
|
|
log_err(1, "sigaction");
|
|
|
|
/*
|
|
* First SIGALRM will arive after conf_timeout seconds.
|
|
* If we do nothing, another one will arrive a second later.
|
|
*/
|
|
log_debugx("setting session timeout to %d seconds", timeout);
|
|
bzero(&itv, sizeof(itv));
|
|
itv.it_interval.tv_sec = 1;
|
|
itv.it_value.tv_sec = timeout;
|
|
error = setitimer(ITIMER_REAL, &itv, NULL);
|
|
if (error != 0)
|
|
log_err(1, "setitimer");
|
|
}
|
|
|
|
static int
|
|
wait_for_children(bool block)
|
|
{
|
|
pid_t pid;
|
|
int status;
|
|
int num = 0;
|
|
|
|
for (;;) {
|
|
/*
|
|
* If "block" is true, wait for at least one process.
|
|
*/
|
|
if (block && num == 0)
|
|
pid = wait4(-1, &status, 0, NULL);
|
|
else
|
|
pid = wait4(-1, &status, WNOHANG, NULL);
|
|
if (pid <= 0)
|
|
break;
|
|
if (WIFSIGNALED(status)) {
|
|
log_warnx("child process %d terminated with signal %d",
|
|
pid, WTERMSIG(status));
|
|
} else if (WEXITSTATUS(status) != 0) {
|
|
log_warnx("child process %d terminated with exit status %d",
|
|
pid, WEXITSTATUS(status));
|
|
} else {
|
|
log_debugx("child process %d terminated gracefully", pid);
|
|
}
|
|
num++;
|
|
}
|
|
|
|
return (num);
|
|
}
|
|
|
|
static void
|
|
handle_connection(struct portal *portal, int fd,
|
|
const struct sockaddr *client_sa, bool dont_fork)
|
|
{
|
|
struct connection *conn;
|
|
int error;
|
|
pid_t pid;
|
|
char host[NI_MAXHOST + 1];
|
|
struct conf *conf;
|
|
|
|
conf = portal->p_portal_group->pg_conf;
|
|
|
|
if (dont_fork) {
|
|
log_debugx("incoming connection; not forking due to -d flag");
|
|
} else {
|
|
nchildren -= wait_for_children(false);
|
|
assert(nchildren >= 0);
|
|
|
|
while (conf->conf_maxproc > 0 && nchildren >= conf->conf_maxproc) {
|
|
log_debugx("maxproc limit of %d child processes hit; "
|
|
"waiting for child process to exit", conf->conf_maxproc);
|
|
nchildren -= wait_for_children(true);
|
|
assert(nchildren >= 0);
|
|
}
|
|
log_debugx("incoming connection; forking child process #%d",
|
|
nchildren);
|
|
nchildren++;
|
|
pid = fork();
|
|
if (pid < 0)
|
|
log_err(1, "fork");
|
|
if (pid > 0) {
|
|
close(fd);
|
|
return;
|
|
}
|
|
}
|
|
pidfile_close(conf->conf_pidfh);
|
|
|
|
error = getnameinfo(client_sa, client_sa->sa_len,
|
|
host, sizeof(host), NULL, 0, NI_NUMERICHOST);
|
|
if (error != 0)
|
|
log_errx(1, "getnameinfo: %s", gai_strerror(error));
|
|
|
|
log_debugx("accepted connection from %s; portal group \"%s\"",
|
|
host, portal->p_portal_group->pg_name);
|
|
log_set_peer_addr(host);
|
|
setproctitle("%s", host);
|
|
|
|
conn = connection_new(portal, fd, host, client_sa);
|
|
set_timeout(conf->conf_timeout, true);
|
|
kernel_capsicate();
|
|
login(conn);
|
|
if (conn->conn_session_type == CONN_SESSION_TYPE_NORMAL) {
|
|
kernel_handoff(conn);
|
|
log_debugx("connection handed off to the kernel");
|
|
} else {
|
|
assert(conn->conn_session_type == CONN_SESSION_TYPE_DISCOVERY);
|
|
discovery(conn);
|
|
}
|
|
log_debugx("nothing more to do; exiting");
|
|
exit(0);
|
|
}
|
|
|
|
static int
|
|
fd_add(int fd, fd_set *fdset, int nfds)
|
|
{
|
|
|
|
/*
|
|
* Skip sockets which we failed to bind.
|
|
*/
|
|
if (fd <= 0)
|
|
return (nfds);
|
|
|
|
FD_SET(fd, fdset);
|
|
if (fd > nfds)
|
|
nfds = fd;
|
|
return (nfds);
|
|
}
|
|
|
|
static void
|
|
main_loop(struct conf *conf, bool dont_fork)
|
|
{
|
|
struct portal_group *pg;
|
|
struct portal *portal;
|
|
struct sockaddr_storage client_sa;
|
|
socklen_t client_salen;
|
|
#ifdef ICL_KERNEL_PROXY
|
|
int connection_id;
|
|
int portal_id;
|
|
#endif
|
|
fd_set fdset;
|
|
int error, nfds, client_fd;
|
|
|
|
pidfile_write(conf->conf_pidfh);
|
|
|
|
for (;;) {
|
|
if (sighup_received || sigterm_received || timed_out())
|
|
return;
|
|
|
|
#ifdef ICL_KERNEL_PROXY
|
|
if (proxy_mode) {
|
|
client_salen = sizeof(client_sa);
|
|
kernel_accept(&connection_id, &portal_id,
|
|
(struct sockaddr *)&client_sa, &client_salen);
|
|
assert(client_salen >= client_sa.ss_len);
|
|
|
|
log_debugx("incoming connection, id %d, portal id %d",
|
|
connection_id, portal_id);
|
|
TAILQ_FOREACH(pg, &conf->conf_portal_groups, pg_next) {
|
|
TAILQ_FOREACH(portal, &pg->pg_portals, p_next) {
|
|
if (portal->p_id == portal_id) {
|
|
goto found;
|
|
}
|
|
}
|
|
}
|
|
|
|
log_errx(1, "kernel returned invalid portal_id %d",
|
|
portal_id);
|
|
|
|
found:
|
|
handle_connection(portal, connection_id,
|
|
(struct sockaddr *)&client_sa, dont_fork);
|
|
} else {
|
|
#endif
|
|
assert(proxy_mode == false);
|
|
|
|
FD_ZERO(&fdset);
|
|
nfds = 0;
|
|
TAILQ_FOREACH(pg, &conf->conf_portal_groups, pg_next) {
|
|
TAILQ_FOREACH(portal, &pg->pg_portals, p_next)
|
|
nfds = fd_add(portal->p_socket, &fdset, nfds);
|
|
}
|
|
error = select(nfds + 1, &fdset, NULL, NULL, NULL);
|
|
if (error <= 0) {
|
|
if (errno == EINTR)
|
|
return;
|
|
log_err(1, "select");
|
|
}
|
|
TAILQ_FOREACH(pg, &conf->conf_portal_groups, pg_next) {
|
|
TAILQ_FOREACH(portal, &pg->pg_portals, p_next) {
|
|
if (!FD_ISSET(portal->p_socket, &fdset))
|
|
continue;
|
|
client_salen = sizeof(client_sa);
|
|
client_fd = accept(portal->p_socket,
|
|
(struct sockaddr *)&client_sa,
|
|
&client_salen);
|
|
if (client_fd < 0) {
|
|
if (errno == ECONNABORTED)
|
|
continue;
|
|
log_err(1, "accept");
|
|
}
|
|
assert(client_salen >= client_sa.ss_len);
|
|
|
|
handle_connection(portal, client_fd,
|
|
(struct sockaddr *)&client_sa,
|
|
dont_fork);
|
|
break;
|
|
}
|
|
}
|
|
#ifdef ICL_KERNEL_PROXY
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
static void
|
|
sighup_handler(int dummy __unused)
|
|
{
|
|
|
|
sighup_received = true;
|
|
}
|
|
|
|
static void
|
|
sigterm_handler(int dummy __unused)
|
|
{
|
|
|
|
sigterm_received = true;
|
|
}
|
|
|
|
static void
|
|
sigchld_handler(int dummy __unused)
|
|
{
|
|
|
|
/*
|
|
* The only purpose of this handler is to make SIGCHLD
|
|
* interrupt the ISCSIDWAIT ioctl(2), so we can call
|
|
* wait_for_children().
|
|
*/
|
|
}
|
|
|
|
static void
|
|
register_signals(void)
|
|
{
|
|
struct sigaction sa;
|
|
int error;
|
|
|
|
bzero(&sa, sizeof(sa));
|
|
sa.sa_handler = sighup_handler;
|
|
sigfillset(&sa.sa_mask);
|
|
error = sigaction(SIGHUP, &sa, NULL);
|
|
if (error != 0)
|
|
log_err(1, "sigaction");
|
|
|
|
sa.sa_handler = sigterm_handler;
|
|
error = sigaction(SIGTERM, &sa, NULL);
|
|
if (error != 0)
|
|
log_err(1, "sigaction");
|
|
|
|
sa.sa_handler = sigterm_handler;
|
|
error = sigaction(SIGINT, &sa, NULL);
|
|
if (error != 0)
|
|
log_err(1, "sigaction");
|
|
|
|
sa.sa_handler = sigchld_handler;
|
|
error = sigaction(SIGCHLD, &sa, NULL);
|
|
if (error != 0)
|
|
log_err(1, "sigaction");
|
|
}
|
|
|
|
static void
|
|
check_perms(const char *path)
|
|
{
|
|
struct stat sb;
|
|
int error;
|
|
|
|
error = stat(path, &sb);
|
|
if (error != 0) {
|
|
log_warn("stat");
|
|
return;
|
|
}
|
|
if (sb.st_mode & S_IWOTH) {
|
|
log_warnx("%s is world-writable", path);
|
|
} else if (sb.st_mode & S_IROTH) {
|
|
log_warnx("%s is world-readable", path);
|
|
} else if (sb.st_mode & S_IXOTH) {
|
|
/*
|
|
* Ok, this one doesn't matter, but still do it,
|
|
* just for consistency.
|
|
*/
|
|
log_warnx("%s is world-executable", path);
|
|
}
|
|
|
|
/*
|
|
* XXX: Should we also check for owner != 0?
|
|
*/
|
|
}
|
|
|
|
static struct conf *
|
|
conf_new_from_file(const char *path, struct conf *oldconf, bool ucl)
|
|
{
|
|
struct conf *conf;
|
|
struct auth_group *ag;
|
|
struct portal_group *pg;
|
|
struct pport *pp;
|
|
int error;
|
|
|
|
log_debugx("obtaining configuration from %s", path);
|
|
|
|
conf = conf_new();
|
|
|
|
TAILQ_FOREACH(pp, &oldconf->conf_pports, pp_next)
|
|
pport_copy(pp, conf);
|
|
|
|
ag = auth_group_new(conf, "default");
|
|
assert(ag != NULL);
|
|
|
|
ag = auth_group_new(conf, "no-authentication");
|
|
assert(ag != NULL);
|
|
ag->ag_type = AG_TYPE_NO_AUTHENTICATION;
|
|
|
|
ag = auth_group_new(conf, "no-access");
|
|
assert(ag != NULL);
|
|
ag->ag_type = AG_TYPE_DENY;
|
|
|
|
pg = portal_group_new(conf, "default");
|
|
assert(pg != NULL);
|
|
|
|
if (ucl)
|
|
error = uclparse_conf(conf, path);
|
|
else
|
|
error = parse_conf(conf, path);
|
|
|
|
if (error != 0) {
|
|
conf_delete(conf);
|
|
return (NULL);
|
|
}
|
|
|
|
check_perms(path);
|
|
|
|
if (conf->conf_default_ag_defined == false) {
|
|
log_debugx("auth-group \"default\" not defined; "
|
|
"going with defaults");
|
|
ag = auth_group_find(conf, "default");
|
|
assert(ag != NULL);
|
|
ag->ag_type = AG_TYPE_DENY;
|
|
}
|
|
|
|
if (conf->conf_default_pg_defined == false) {
|
|
log_debugx("portal-group \"default\" not defined; "
|
|
"going with defaults");
|
|
pg = portal_group_find(conf, "default");
|
|
assert(pg != NULL);
|
|
portal_group_add_listen(pg, "0.0.0.0:3260", false);
|
|
portal_group_add_listen(pg, "[::]:3260", false);
|
|
}
|
|
|
|
conf->conf_kernel_port_on = true;
|
|
|
|
error = conf_verify(conf);
|
|
if (error != 0) {
|
|
conf_delete(conf);
|
|
return (NULL);
|
|
}
|
|
|
|
return (conf);
|
|
}
|
|
|
|
int
|
|
main(int argc, char **argv)
|
|
{
|
|
struct conf *oldconf, *newconf, *tmpconf;
|
|
struct isns *newns;
|
|
const char *config_path = DEFAULT_CONFIG_PATH;
|
|
int debug = 0, ch, error;
|
|
bool dont_daemonize = false;
|
|
bool use_ucl = false;
|
|
|
|
while ((ch = getopt(argc, argv, "duf:R")) != -1) {
|
|
switch (ch) {
|
|
case 'd':
|
|
dont_daemonize = true;
|
|
debug++;
|
|
break;
|
|
case 'u':
|
|
use_ucl = true;
|
|
break;
|
|
case 'f':
|
|
config_path = optarg;
|
|
break;
|
|
case 'R':
|
|
#ifndef ICL_KERNEL_PROXY
|
|
log_errx(1, "ctld(8) compiled without ICL_KERNEL_PROXY "
|
|
"does not support iSER protocol");
|
|
#endif
|
|
proxy_mode = true;
|
|
break;
|
|
case '?':
|
|
default:
|
|
usage();
|
|
}
|
|
}
|
|
argc -= optind;
|
|
if (argc != 0)
|
|
usage();
|
|
|
|
log_init(debug);
|
|
kernel_init();
|
|
|
|
oldconf = conf_new_from_kernel();
|
|
newconf = conf_new_from_file(config_path, oldconf, use_ucl);
|
|
|
|
if (newconf == NULL)
|
|
log_errx(1, "configuration error; exiting");
|
|
if (debug > 0) {
|
|
oldconf->conf_debug = debug;
|
|
newconf->conf_debug = debug;
|
|
}
|
|
|
|
error = conf_apply(oldconf, newconf);
|
|
if (error != 0)
|
|
log_errx(1, "failed to apply configuration; exiting");
|
|
|
|
conf_delete(oldconf);
|
|
oldconf = NULL;
|
|
|
|
register_signals();
|
|
|
|
if (dont_daemonize == false) {
|
|
log_debugx("daemonizing");
|
|
if (daemon(0, 0) == -1) {
|
|
log_warn("cannot daemonize");
|
|
pidfile_remove(newconf->conf_pidfh);
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
/* Schedule iSNS update */
|
|
if (!TAILQ_EMPTY(&newconf->conf_isns))
|
|
set_timeout((newconf->conf_isns_period + 2) / 3, false);
|
|
|
|
for (;;) {
|
|
main_loop(newconf, dont_daemonize);
|
|
if (sighup_received) {
|
|
sighup_received = false;
|
|
log_debugx("received SIGHUP, reloading configuration");
|
|
tmpconf = conf_new_from_file(config_path, newconf,
|
|
use_ucl);
|
|
|
|
if (tmpconf == NULL) {
|
|
log_warnx("configuration error, "
|
|
"continuing with old configuration");
|
|
} else {
|
|
if (debug > 0)
|
|
tmpconf->conf_debug = debug;
|
|
oldconf = newconf;
|
|
newconf = tmpconf;
|
|
error = conf_apply(oldconf, newconf);
|
|
if (error != 0)
|
|
log_warnx("failed to reload "
|
|
"configuration");
|
|
conf_delete(oldconf);
|
|
oldconf = NULL;
|
|
}
|
|
} else if (sigterm_received) {
|
|
log_debugx("exiting on signal; "
|
|
"reloading empty configuration");
|
|
|
|
log_debugx("removing CTL iSCSI ports "
|
|
"and terminating all connections");
|
|
|
|
oldconf = newconf;
|
|
newconf = conf_new();
|
|
if (debug > 0)
|
|
newconf->conf_debug = debug;
|
|
error = conf_apply(oldconf, newconf);
|
|
if (error != 0)
|
|
log_warnx("failed to apply configuration");
|
|
conf_delete(oldconf);
|
|
oldconf = NULL;
|
|
|
|
log_warnx("exiting on signal");
|
|
exit(0);
|
|
} else {
|
|
nchildren -= wait_for_children(false);
|
|
assert(nchildren >= 0);
|
|
if (timed_out()) {
|
|
set_timeout(0, false);
|
|
TAILQ_FOREACH(newns, &newconf->conf_isns, i_next)
|
|
isns_check(newns);
|
|
/* Schedule iSNS update */
|
|
if (!TAILQ_EMPTY(&newconf->conf_isns)) {
|
|
set_timeout((newconf->conf_isns_period
|
|
+ 2) / 3,
|
|
false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/* NOTREACHED */
|
|
}
|