Attachment #154087 for bug #198396

Lines 7-12 Link Here

(-)./Makefile (+1 lines)
7	MAN= iscsi.conf.5 iscsictl.8	7	MAN= iscsi.conf.5 iscsictl.8
8		8
9	LIBADD= cam util	9	LIBADD= cam util
		10	LDADD= -lxo
10		11
11	YFLAGS+= -v	12	YFLAGS+= -v
12	LFLAGS+= -i	13	LFLAGS+= -i




#include <sys/linker.h>
#include <assert.h>
#include <ctype.h>
#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>

#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <libxo/xo.h>

#include <iscsi_ioctl.h>
#include "iscsictl.h"


	conf = calloc(1, sizeof(*conf));
	if (conf == NULL)
		xo_err(1, "calloc");

	TAILQ_INIT(&conf->conf_targets);



	targ = calloc(1, sizeof(*targ));
	if (targ == NULL)
		xo_err(1, "calloc");
	targ->t_conf = conf;
	TAILQ_INSERT_TAIL(&conf->conf_targets, targ, t_next);



	name = calloc(1, namelen + 1);
	if (name == NULL)
		xo_err(1, "calloc");
	strcpy(name, DEFAULT_IQN);
	error = gethostname(name + strlen(DEFAULT_IQN),
	    namelen - strlen(DEFAULT_IQN));
	if (error != 0)
		xo_err(1, "gethostname");

	return (name);
}

	int i;

	if (strlen(name) >= MAX_NAME_LEN) {
		xo_warnx("overlong name for \"%s\"; max length allowed "
		    "by iSCSI specification is %d characters",
		    name, MAX_NAME_LEN);
		return (false);

				continue;
			if (name[i] == '-' || name[i] == '.' || name[i] == ':')
				continue;
			xo_warnx("invalid character \"%c\" in iSCSI name "
			    "\"%s\"; allowed characters are letters, digits, "
			    "'-', '.', and ':'", name[i], name);
			break;

		 */
	} else if (strncasecmp(name, "eui.", strlen("eui.")) == 0) {
		if (strlen(name) != strlen("eui.") + 16)
			xo_warnx("invalid iSCSI 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])) {
				xo_warnx("invalid character \"%c\" in iSCSI "
				    "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)
			xo_warnx("invalid iSCSI 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])) {
				xo_warnx("invalid character \"%c\" in ISCSI "
				    "name \"%s\"; allowed characters are 1-9 "
				    "and A-F", name[i], name);
				break;
			}
		}
	} else {
		xo_warnx("invalid iSCSI name \"%s\"; should start with "
		    "either \".iqn\", \"eui.\", or \"naa.\"",
		    name);
	}

			targ->t_session_type = SESSION_TYPE_NORMAL;
		if (targ->t_session_type == SESSION_TYPE_NORMAL &&
		    targ->t_name == NULL)
			xo_errx(1, "missing TargetName for target \"%s\"",
			    targ->t_nickname);
		if (targ->t_session_type == SESSION_TYPE_DISCOVERY &&
		    targ->t_name != NULL)
			xo_errx(1, "cannot specify TargetName for discovery "
			    "sessions for target \"%s\"", targ->t_nickname);
		if (targ->t_name != NULL) {
			if (valid_iscsi_name(targ->t_name) == false)
				xo_errx(1, "invalid target name \"%s\"",
				    targ->t_name);
		}
		if (targ->t_protocol == PROTOCOL_UNSPECIFIED)
			targ->t_protocol = PROTOCOL_ISCSI;
		if (targ->t_address == NULL)
			xo_errx(1, "missing TargetAddress for target \"%s\"",
			    targ->t_nickname);
		if (targ->t_initiator_name == NULL)
			targ->t_initiator_name = default_initiator_name();
		if (valid_iscsi_name(targ->t_initiator_name) == false)
			xo_errx(1, "invalid initiator name \"%s\"",
			    targ->t_initiator_name);
		if (targ->t_header_digest == DIGEST_UNSPECIFIED)
			targ->t_header_digest = DIGEST_NONE;

		}
		if (targ->t_auth_method == AUTH_METHOD_CHAP) {
			if (targ->t_user == NULL) {
				xo_errx(1, "missing chapIName for target \"%s\"",
				    targ->t_nickname);
			}
			if (targ->t_secret == NULL)
				xo_errx(1, "missing chapSecret for target \"%s\"",
				    targ->t_nickname);
			if (targ->t_mutual_user != NULL ||
			    targ->t_mutual_secret != NULL) {
				if (targ->t_mutual_user == NULL)
					xo_errx(1, "missing tgtChapName for "
					    "target \"%s\"", targ->t_nickname);
				if (targ->t_mutual_secret == NULL)
					xo_errx(1, "missing tgtChapSecret for "
					    "target \"%s\"", targ->t_nickname);
			}
		}

	conf_from_target(&isa.isa_conf, targ);
	error = ioctl(iscsi_fd, ISCSISADD, &isa);
	if (error != 0)
		xo_warn("ISCSISADD");
	return (error);
}


	conf_from_target(&ism.ism_conf, targ);
	error = ioctl(iscsi_fd, ISCSISMODIFY, &ism);
	if (error != 0)
		xo_warn("ISCSISMODIFY");
	return (error);
}


		states = realloc(states,
		    nentries * sizeof(struct iscsi_session_state));
		if (states == NULL)
			xo_err(1, "realloc");

		memset(&isl, 0, sizeof(isl));
		isl.isl_nentries = nentries;

		break;
	}
	if (error != 0)
		xo_errx(1, "ISCSISLIST");

	for (i = 0; i < isl.isl_nentries; i++) {
		state = &states[i];

			break;
	}
	if (i == isl.isl_nentries)
		xo_errx(1, "session-id %u not found", session_id);

	conf = &state->iss_conf;


	memcpy(&ism.ism_conf, conf, sizeof(ism.ism_conf));
	error = ioctl(iscsi_fd, ISCSISMODIFY, &ism);
	if (error != 0)
		xo_warn("ISCSISMODIFY");
}

static int

	conf_from_target(&isr.isr_conf, targ);
	error = ioctl(iscsi_fd, ISCSISREMOVE, &isr);
	if (error != 0)
		xo_warn("ISCSISREMOVE");
	return (error);
}


		states = realloc(states,
		    nentries * sizeof(struct iscsi_session_state));
		if (states == NULL)
			xo_err(1, "realloc");

		memset(&isl, 0, sizeof(isl));
		isl.isl_nentries = nentries;

		break;
	}
	if (error != 0) {
		xo_warn("ISCSISLIST");
		return (error);
	}

	if (verbose != 0) {
		xo_open_list("target");
		for (i = 0; i < isl.isl_nentries; i++) {
			state = &states[i];
			conf = &state->iss_conf;
			
			xo_open_instance("target");
			
			/* 
			 * Display-only modifier as this information
			 * is also present within the 'session' container
			 */
			xo_emit("{Ld:/%-18s}{Vd:sessionId/%u}\n",
				"Session ID:", state->iss_id);
			
			/* Start Container: initiator */
			xo_open_container("initiator");
			xo_emit("{L:/%-18s}{V:name/%s}\n",
				"Initiator name:", conf->isc_initiator);
			xo_emit("{L:/%-18s}{V:portal/%s}\n",
				"Initiator portal:", conf->isc_initiator_addr);
			xo_emit("{L:/%-18s}{V:alias/%s}\n",
				"Initiator alias:", conf->isc_initiator_alias);
			xo_close_container("initiator");
			/* End Container: initiator */
			
			/* Start Container: target */
			xo_open_container("target");
			xo_emit("{L:/%-18s}{V:name/%s}\n",
				"Target name:", conf->isc_target);
			xo_emit("{L:/%-18s}{V:portal/%s}\n",
				"Target portal:", conf->isc_target_addr);
			xo_emit("{L:/%-18s}{V:alias/%s}\n",
				"Target alias:", state->iss_target_alias);
			xo_close_container("target");
			/* End Container: target */
			
			/* Start Container: auth */
			xo_open_container("auth");
			xo_emit("{L:/%-18s}{V:user/%s}\n",
				"User:", conf->isc_user);
			xo_emit("{L:/%-18s}{V:secret/%s}\n",
				"Secret:", conf->isc_secret);
			xo_emit("{L:/%-18s}{V:mutualUser/%s}\n",
				"Mutual user:", conf->isc_mutual_user);
			xo_emit("{L:/%-18s}{V:mutualSecret/%s}\n",
				"Mutual secret:", conf->isc_mutual_secret);
			xo_close_container("auth");
			/* End Container: auth */
			
			/* Start Container: session */
			xo_open_container("session");
			/*  
			 * Session ID is already printed for 
			 * display outputs. Only include it for
			 * non-display output. 
			 */
			xo_emit("{Ve:id/%u}",
				state->iss_id);
			xo_emit("{L:/%-18s}{V:type/%s}\n",
				"Session type:", (conf->isc_discovery ? "Discovery" : "Normal"));
			xo_emit("{L:/%-18s}{V:state/%s}\n",
				"Session state:", 
				(state->iss_connected ?
			    "Connected" : "Disconnected"));
			xo_close_container("session");
			/* End Container: session */
			
			xo_emit("{L:/%-18s}{V:failureReason/%s}\n",
				"Failure reason:", state->iss_reason);
			
			/* Start Container: digest */
			xo_open_container("digest");
			xo_emit("{L:/%-18s}{V:header/%s}\n",
				"Header digest:", 
				(state->iss_header_digest == ISCSI_DIGEST_CRC32C ?
			    "CRC32C" : "None"));
			xo_emit("{L:/%-18s}{V:data/%s}\n",
				"Data digest:", 
				(state->iss_data_digest == ISCSI_DIGEST_CRC32C ?
			    "CRC32C" : "None"));
			xo_close_container("digest");
			/* End Container: digest */
			
			xo_emit("{L:/%-18s}{V:dataSegmentLen/%d}\n",
				"DataSegmentLen:", state->iss_max_data_segment_length);
			xo_emit("{L:/%-18s}{V:immediateData/%s}\n",
				"ImmediateData:", state->iss_immediate_data ? "Yes" : "No");
			xo_emit("{L:/%-18s}{V:iSER/%s}\n",
				"iSER (RDMA):", conf->isc_iser ? "Yes" : "No");
			
			xo_emit("{L:/%-18s}{V:offloadDriver/%s}\n",
				"Offload driver:", state->iss_offload);
			xo_emit("{L:/%-18s}",
				"Device nodes:");
			print_periphs(state->iss_id);
			xo_emit("\n\n");
			xo_close_instance("target");
		}
		xo_close_list("target");
	} else {
		xo_emit("{T:/%-36s} {T:/%-16s} {T:/%s}\n",
			"Target name", "Target portal", "State");
		
		for (i = 0; i < isl.isl_nentries; i++) {
			if (i == 0) {
				xo_open_list("target");
			}
			
			state = &states[i];
			conf = &state->iss_conf;

			xo_open_instance("target");
			xo_emit("{V:name/%-36s/%s} {V:portal/%-16s/%s} ",
				conf->isc_target, conf->isc_target_addr);
			
			if (state->iss_reason[0] != '\0') {
				xo_emit("{V:state/%s", state->iss_reason);
			} else {
				if (conf->isc_discovery) {
					xo_emit("{V:state}\n", "Discovery");
				} else if (state->iss_connected) {
					xo_emit("{V:state}: ", "Connected");
					print_periphs(state->iss_id);
					xo_emit("\n");
				} else {
					xo_emit("{V:state}\n", "Disconnected");
				}
			}
			xo_close_instance("target");
		}
		if (isl.isl_nentries != 0) {
			xo_close_list("target");
		}
	}



	c = strdup(s);
	if (c == NULL)
		xo_err(1, "strdup");
	return (c);
}


	int failed = 0;
	struct conf *conf;
	struct target *targ;
	
	argc = xo_parse_args(argc, argv);
	xo_open_container("iscsictl");
	
	while ((ch = getopt(argc, argv, "AMRLac:d:i:n:p:t:u:s:v")) != -1) {
		switch (ch) {
		case 'A':

		case 'i':
			session_id = strtol(optarg, &end, 10);
			if ((size_t)(end - optarg) != strlen(optarg))
				xo_errx(1, "trailing characters after session-id");
			if (session_id < 0)
				xo_errx(1, "session-id cannot be negative");
			if (session_id > UINT_MAX)
				xo_errx(1, "session-id cannot be greater than %u",
				    UINT_MAX);
			break;
		case 'n':

	if (Aflag + Mflag + Rflag + Lflag == 0)
		Lflag = 1;
	if (Aflag + Mflag + Rflag + Lflag > 1)
		xo_errx(1, "at most one of -A, -M, -R, or -L may be specified");

	/*
	 * Note that we ignore unneccessary/inapplicable "-c" flag; so that

	if (Aflag != 0) {
		if (aflag != 0) {
			if (portal != NULL)
				xo_errx(1, "-a and -p and mutually exclusive");
			if (target != NULL)
				xo_errx(1, "-a and -t and mutually exclusive");
			if (user != NULL)
				xo_errx(1, "-a and -u and mutually exclusive");
			if (secret != NULL)
				xo_errx(1, "-a and -s and mutually exclusive");
			if (nickname != NULL)
				xo_errx(1, "-a and -n and mutually exclusive");
			if (discovery_host != NULL)
				xo_errx(1, "-a and -d and mutually exclusive");
		} else if (nickname != NULL) {
			if (portal != NULL)
				xo_errx(1, "-n and -p and mutually exclusive");
			if (target != NULL)
				xo_errx(1, "-n and -t and mutually exclusive");
			if (user != NULL)
				xo_errx(1, "-n and -u and mutually exclusive");
			if (secret != NULL)
				xo_errx(1, "-n and -s and mutually exclusive");
			if (discovery_host != NULL)
				xo_errx(1, "-n and -d and mutually exclusive");
		} else if (discovery_host != NULL) {
			if (portal != NULL)
				xo_errx(1, "-d and -p and mutually exclusive");
			if (target != NULL)
				xo_errx(1, "-d and -t and mutually exclusive");
		} else {
			if (target == NULL && portal == NULL)
				xo_errx(1, "must specify -a, -n or -t/-p");

			if (target != NULL && portal == NULL)
				xo_errx(1, "-t must always be used with -p");
			if (portal != NULL && target == NULL)
				xo_errx(1, "-p must always be used with -t");
		}

		if (user != NULL && secret == NULL)
			xo_errx(1, "-u must always be used with -s");
		if (secret != NULL && user == NULL)
			xo_errx(1, "-s must always be used with -u");

		if (session_id != -1)
			xo_errx(1, "-i cannot be used with -A");
		if (vflag != 0)
			xo_errx(1, "-v cannot be used with -A");

	} else if (Mflag != 0) {
		if (session_id == -1)
			xo_errx(1, "-M requires -i");

		if (discovery_host != NULL)
			xo_errx(1, "-M and -d are mutually exclusive");
		if (aflag != 0)
			xo_errx(1, "-M and -a are mutually exclusive");
		if (nickname != NULL) {
			if (portal != NULL)
				xo_errx(1, "-n and -p and mutually exclusive");
			if (target != NULL)
				xo_errx(1, "-n and -t and mutually exclusive");
			if (user != NULL)
				xo_errx(1, "-n and -u and mutually exclusive");
			if (secret != NULL)
				xo_errx(1, "-n and -s and mutually exclusive");
		}

		if (vflag != 0)
			xo_errx(1, "-v cannot be used with -M");

	} else if (Rflag != 0) {
		if (user != NULL)
			xo_errx(1, "-R and -u are mutually exclusive");
		if (secret != NULL)
			xo_errx(1, "-R and -s are mutually exclusive");
		if (discovery_host != NULL)
			xo_errx(1, "-R and -d are mutually exclusive");

		if (aflag != 0) {
			if (portal != NULL)
				xo_errx(1, "-a and -p and mutually exclusive");
			if (target != NULL)
				xo_errx(1, "-a and -t and mutually exclusive");
			if (nickname != NULL)
				xo_errx(1, "-a and -n and mutually exclusive");
		} else if (nickname != NULL) {
			if (portal != NULL)
				xo_errx(1, "-n and -p and mutually exclusive");
			if (target != NULL)
				xo_errx(1, "-n and -t and mutually exclusive");
		} else if (target == NULL && portal == NULL) {
			xo_errx(1, "must specify either -a, -n, -t, or -p");
		}

		if (session_id != -1)
			xo_errx(1, "-i cannot be used with -R");
		if (vflag != 0)
			xo_errx(1, "-v cannot be used with -R");

	} else {
		assert(Lflag != 0);
		
		if (portal != NULL)
			xo_errx(1, "-L and -p and mutually exclusive");
		if (target != NULL)
			xo_errx(1, "-L and -t and mutually exclusive");
		if (user != NULL)
			xo_errx(1, "-L and -u and mutually exclusive");
		if (secret != NULL)
			xo_errx(1, "-L and -s and mutually exclusive");
		if (nickname != NULL)
			xo_errx(1, "-L and -n and mutually exclusive");
		if (discovery_host != NULL)
			xo_errx(1, "-L and -d and mutually exclusive");

		if (session_id != -1)
			xo_errx(1, "-i cannot be used with -L");
	}

	iscsi_fd = open(ISCSI_PATH, O_RDWR);

			errno = saved_errno;
	}
	if (iscsi_fd < 0)
		xo_err(1, "failed to open %s", ISCSI_PATH);

	if (Aflag != 0 && aflag != 0) {
		conf = conf_new_from_file(conf_path);

		conf = conf_new_from_file(conf_path);
		targ = target_find(conf, nickname);
		if (targ == NULL)
			xo_errx(1, "target %s not found in %s",
			    nickname, conf_path);

		if (Aflag != 0)

	} else {
		if (Aflag != 0 && target != NULL) {
			if (valid_iscsi_name(target) == false)
				xo_errx(1, "invalid target name \"%s\"", target);
		}
		conf = conf_new();
		targ = target_new(conf);

		else
			failed += kernel_list(iscsi_fd, targ, vflag);
	}
	
	error = close(iscsi_fd);
	if (error != 0)
		xo_err(1, "close");
		
	if (failed > 0)
		return (1);
		
	xo_close_container("iscsictl");
	xo_finish();
	return (0);
}




#include <sys/types.h>
#include <sys/stat.h>
#include <assert.h>
#include <err.h>
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>

#include <libxo/xo.h>

#include "iscsictl.h"

extern FILE *yyin;

target:		STR OPENING_BRACKET target_entries CLOSING_BRACKET
	{
		if (target_find(conf, $1) != NULL)
			xo_errx(1, "duplicated target %s", $1);
		target->t_nickname = $1;
		target = target_new(conf);
	}

target_name:	TARGET_NAME EQUALS STR
	{
		if (target->t_name != NULL)
			xo_errx(1, "duplicated TargetName at line %d", lineno);
		target->t_name = $3;
	}
	;

target_address:	TARGET_ADDRESS EQUALS STR
	{
		if (target->t_address != NULL)
			xo_errx(1, "duplicated TargetAddress at line %d", lineno);
		target->t_address = $3;
	}
	;

initiator_name:	INITIATOR_NAME EQUALS STR
	{
		if (target->t_initiator_name != NULL)
			xo_errx(1, "duplicated InitiatorName at line %d", lineno);
		target->t_initiator_name = $3;
	}
	;

initiator_address:	INITIATOR_ADDRESS EQUALS STR
	{
		if (target->t_initiator_address != NULL)
			xo_errx(1, "duplicated InitiatorAddress at line %d", lineno);
		target->t_initiator_address = $3;
	}
	;

initiator_alias:	INITIATOR_ALIAS EQUALS STR
	{
		if (target->t_initiator_alias != NULL)
			xo_errx(1, "duplicated InitiatorAlias at line %d", lineno);
		target->t_initiator_alias = $3;
	}
	;

user:		USER EQUALS STR
	{
		if (target->t_user != NULL)
			xo_errx(1, "duplicated chapIName at line %d", lineno);
		target->t_user = $3;
	}
	;

secret:		SECRET EQUALS STR
	{
		if (target->t_secret != NULL)
			xo_errx(1, "duplicated chapSecret at line %d", lineno);
		target->t_secret = $3;
	}
	;

mutual_user:	MUTUAL_USER EQUALS STR
	{
		if (target->t_mutual_user != NULL)
			xo_errx(1, "duplicated tgtChapName at line %d", lineno);
		target->t_mutual_user = $3;
	}
	;

mutual_secret:	MUTUAL_SECRET EQUALS STR
	{
		if (target->t_mutual_secret != NULL)
			xo_errx(1, "duplicated tgtChapSecret at line %d", lineno);
		target->t_mutual_secret = $3;
	}
	;

auth_method:	AUTH_METHOD EQUALS STR
	{
		if (target->t_auth_method != AUTH_METHOD_UNSPECIFIED)
			xo_errx(1, "duplicated AuthMethod at line %d", lineno);
		if (strcasecmp($3, "none") == 0)
			target->t_auth_method = AUTH_METHOD_NONE;
		else if (strcasecmp($3, "chap") == 0)
			target->t_auth_method = AUTH_METHOD_CHAP;
		else
			xo_errx(1, "invalid AuthMethod at line %d; "
			    "must be either \"none\" or \"CHAP\"", lineno);
	}
	;

header_digest:	HEADER_DIGEST EQUALS STR
	{
		if (target->t_header_digest != DIGEST_UNSPECIFIED)
			xo_errx(1, "duplicated HeaderDigest at line %d", lineno);
		if (strcasecmp($3, "none") == 0)
			target->t_header_digest = DIGEST_NONE;
		else if (strcasecmp($3, "CRC32C") == 0)
			target->t_header_digest = DIGEST_CRC32C;
		else
			xo_errx(1, "invalid HeaderDigest at line %d; "
			    "must be either \"none\" or \"CRC32C\"", lineno);
	}
	;

data_digest:	DATA_DIGEST EQUALS STR
	{
		if (target->t_data_digest != DIGEST_UNSPECIFIED)
			xo_errx(1, "duplicated DataDigest at line %d", lineno);
		if (strcasecmp($3, "none") == 0)
			target->t_data_digest = DIGEST_NONE;
		else if (strcasecmp($3, "CRC32C") == 0)
			target->t_data_digest = DIGEST_CRC32C;
		else
			xo_errx(1, "invalid DataDigest at line %d; "
			    "must be either \"none\" or \"CRC32C\"", lineno);
	}
	;

session_type:	SESSION_TYPE EQUALS STR
	{
		if (target->t_session_type != SESSION_TYPE_UNSPECIFIED)
			xo_errx(1, "duplicated SessionType at line %d", lineno);
		if (strcasecmp($3, "normal") == 0)
			target->t_session_type = SESSION_TYPE_NORMAL;
		else if (strcasecmp($3, "discovery") == 0)
			target->t_session_type = SESSION_TYPE_DISCOVERY;
		else
			xo_errx(1, "invalid SessionType at line %d; "
			    "must be either \"normal\" or \"discovery\"", lineno);
	}
	;

offload:	OFFLOAD EQUALS STR
	{
		if (target->t_offload != NULL)
			xo_errx(1, "duplicated offload at line %d", lineno);
		target->t_offload = $3;
	}
	;

protocol:	PROTOCOL EQUALS STR
	{
		if (target->t_protocol != PROTOCOL_UNSPECIFIED)
			xo_errx(1, "duplicated protocol at line %d", lineno);
		if (strcasecmp($3, "iscsi") == 0)
			target->t_protocol = PROTOCOL_ISCSI;
		else if (strcasecmp($3, "iser") == 0)
			target->t_protocol = PROTOCOL_ISER;
		else
			xo_errx(1, "invalid protocol at line %d; "
			    "must be either \"iscsi\" or \"iser\"", lineno);
	}
	;

ignored:	IGNORED EQUALS STR
	{
		xo_warnx("obsolete statement ignored at line %d", lineno);
	}
	;


yyerror(const char *str)
{

	xo_errx(1, "error in configuration file at line %d near '%s': %s",
	    lineno, yytext, str);
}



	error = stat(path, &sb);
	if (error != 0) {
		xo_warn("stat");
		return;
	}
	if (sb.st_mode & S_IWOTH) {
		xo_warnx("%s is world-writable", path);
	} else if (sb.st_mode & S_IROTH) {
		xo_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.
		 */
		xo_warnx("%s is world-executable", path);
	}

	/*




#include <inttypes.h>
#include <limits.h>
#include <fcntl.h>
#include <err.h>

#include <cam/cam.h>
#include <cam/cam_debug.h>

#include <cam/scsi/smp_all.h>
#include <cam/ata/ata_all.h>
#include <camlib.h>
#include <libxo/xo.h>

#include "iscsictl.h"


	int skip_bus, skip_device;

	if ((fd = open(XPT_DEVICE, O_RDWR)) == -1) {
		xo_warn("couldn't open %s", XPT_DEVICE);
		return;
	}
		
	/*
	 * First, iterate over the whole list to find the bus.
	 */

	ccb.cdm.match_buf_len = bufsize;
	ccb.cdm.matches = (struct dev_match_result *)malloc(bufsize);
	if (ccb.cdm.matches == NULL) {
		xo_warnx("can't malloc memory for matches");
		close(fd);
		return;
	}


	skip_bus = 1;
	skip_device = 1;
	
	int lun_no=0;
	xo_open_list("lun");
	/*
	 * We do the ioctl multiple times if necessary, in case there are
	 * more than 100 nodes in the EDT.
	 */
	do {
		if (ioctl(fd, CAMIOCOMMAND, &ccb) == -1) {
			xo_warn("error sending CAMIOCOMMAND ioctl");
			break;
		}

		if ((ccb.ccb_h.status != CAM_REQ_CMP)
		 || ((ccb.cdm.status != CAM_DEV_MATCH_LAST)
		    && (ccb.cdm.status != CAM_DEV_MATCH_MORE))) {
			xo_warnx("got CAM error %#x, CDM error %d\n",
			      ccb.ccb_h.status, ccb.cdm.status);
			break;
		}
		
		

		for (i = 0; i < ccb.cdm.num_matches; i++) {
			switch (ccb.cdm.matches[i].type) {

				if (strcmp(periph_result->periph_name, "pass") == 0)
					continue;

				xo_open_instance("lun");	
				xo_emit("{e:id/%d}", lun_no);
				xo_emit("{Vq:device/%s%d} ",
					periph_result->periph_name,
					periph_result->unit_number);
				xo_close_instance("lun");
				lun_no++;

				break;
			}


	} while ((ccb.ccb_h.status == CAM_REQ_CMP)
		&& (ccb.cdm.status == CAM_DEV_MATCH_MORE));
	
	xo_close_list("lun");
	close(fd);
}


Return to bug 198396

Lines 46-52 Link Here

(-)./periphs.c (-9 / +18 lines)
46	#include <inttypes.h>	46	#include <inttypes.h>
47	#include <limits.h>	47	#include <limits.h>
48	#include <fcntl.h>	48	#include <fcntl.h>
49	#include <err.h>
50		49
51	#include <cam/cam.h>	50	#include <cam/cam.h>
52	#include <cam/cam_debug.h>	51	#include <cam/cam_debug.h>
Lines 58-63 Link Here
58	#include <cam/scsi/smp_all.h>	57	#include <cam/scsi/smp_all.h>
59	#include <cam/ata/ata_all.h>	58	#include <cam/ata/ata_all.h>
60	#include <camlib.h>	59	#include <camlib.h>
		60	#include <libxo/xo.h>
61		61
62	#include "iscsictl.h"	62	#include "iscsictl.h"
63		63
Lines 70-79 Link Here
70	int skip_bus, skip_device;	70	int skip_bus, skip_device;
71		71
72	if ((fd = open(XPT_DEVICE, O_RDWR)) == -1) {	72	if ((fd = open(XPT_DEVICE, O_RDWR)) == -1) {
73	warn("couldn't open %s", XPT_DEVICE);	73	xo_warn("couldn't open %s", XPT_DEVICE);
74	return;	74	return;
75	}	75	}
76		76
77	/*	77	/*
78	* First, iterate over the whole list to find the bus.	78	* First, iterate over the whole list to find the bus.
79	*/	79	*/
Lines 89-95 Link Here
89	ccb.cdm.match_buf_len = bufsize;	89	ccb.cdm.match_buf_len = bufsize;
90	ccb.cdm.matches = (struct dev_match_result *)malloc(bufsize);	90	ccb.cdm.matches = (struct dev_match_result *)malloc(bufsize);
91	if (ccb.cdm.matches == NULL) {	91	if (ccb.cdm.matches == NULL) {
92	warnx("can't malloc memory for matches");	92	xo_warnx("can't malloc memory for matches");
93	close(fd);	93	close(fd);
94	return;	94	return;
95	}	95	}
Lines 104-127 Link Here
104		104
105	skip_bus = 1;	105	skip_bus = 1;
106	skip_device = 1;	106	skip_device = 1;
107		107
		108	int lun_no=0;
		109	xo_open_list("lun");
108	/*	110	/*
109	* We do the ioctl multiple times if necessary, in case there are	111	* We do the ioctl multiple times if necessary, in case there are
110	* more than 100 nodes in the EDT.	112	* more than 100 nodes in the EDT.
111	*/	113	*/
112	do {	114	do {
113	if (ioctl(fd, CAMIOCOMMAND, &ccb) == -1) {	115	if (ioctl(fd, CAMIOCOMMAND, &ccb) == -1) {
114	warn("error sending CAMIOCOMMAND ioctl");	116	xo_warn("error sending CAMIOCOMMAND ioctl");
115	break;	117	break;
116	}	118	}
117		119
118	if ((ccb.ccb_h.status != CAM_REQ_CMP)	120	if ((ccb.ccb_h.status != CAM_REQ_CMP)
119	\|\| ((ccb.cdm.status != CAM_DEV_MATCH_LAST)	121	\|\| ((ccb.cdm.status != CAM_DEV_MATCH_LAST)
120	&& (ccb.cdm.status != CAM_DEV_MATCH_MORE))) {	122	&& (ccb.cdm.status != CAM_DEV_MATCH_MORE))) {
121	warnx("got CAM error %#x, CDM error %d\n",	123	xo_warnx("got CAM error %#x, CDM error %d\n",
122	ccb.ccb_h.status, ccb.cdm.status);	124	ccb.ccb_h.status, ccb.cdm.status);
123	break;	125	break;
124	}	126	}
		127
		128
125		129
126	for (i = 0; i < ccb.cdm.num_matches; i++) {	130	for (i = 0; i < ccb.cdm.num_matches; i++) {
127	switch (ccb.cdm.matches[i].type) {	131	switch (ccb.cdm.matches[i].type) {
Lines 166-174 Link Here
166	if (strcmp(periph_result->periph_name, "pass") == 0)	170	if (strcmp(periph_result->periph_name, "pass") == 0)
167	continue;	171	continue;
168		172
169	fprintf(stdout, "%s%d ",	173	xo_open_instance("lun");
		174	xo_emit("{e:id/%d}", lun_no);
		175	xo_emit("{Vq:device/%s%d} ",
170	periph_result->periph_name,	176	periph_result->periph_name,
171	periph_result->unit_number);	177	periph_result->unit_number);
		178	xo_close_instance("lun");
		179	lun_no++;
172		180
173	break;	181	break;
174	}	182	}
Lines 180-186 Link Here
180		188
181	} while ((ccb.ccb_h.status == CAM_REQ_CMP)	189	} while ((ccb.ccb_h.status == CAM_REQ_CMP)
182	&& (ccb.cdm.status == CAM_DEV_MATCH_MORE));	190	&& (ccb.cdm.status == CAM_DEV_MATCH_MORE));
183		191
		192	xo_close_list("lun");
184	close(fd);	193	close(fd);
185	}	194	}
186		195

Lines 34-45 Link Here

(-)./parse.y (-28 / +29 lines)
34	#include <sys/types.h>	34	#include <sys/types.h>
35	#include <sys/stat.h>	35	#include <sys/stat.h>
36	#include <assert.h>	36	#include <assert.h>
37	#include <err.h>
38	#include <stdio.h>	37	#include <stdio.h>
39	#include <stdint.h>	38	#include <stdint.h>
40	#include <stdlib.h>	39	#include <stdlib.h>
41	#include <string.h>	40	#include <string.h>
42		41
		42	#include <libxo/xo.h>
		43
43	#include "iscsictl.h"	44	#include "iscsictl.h"
44		45
45	extern FILE *yyin;	46	extern FILE *yyin;
Lines 77-83 Link Here
77	target: STR OPENING_BRACKET target_entries CLOSING_BRACKET	78	target: STR OPENING_BRACKET target_entries CLOSING_BRACKET
78	{	79	{
79	if (target_find(conf, $1) != NULL)	80	if (target_find(conf, $1) != NULL)
80	errx(1, "duplicated target %s", $1);	81	xo_errx(1, "duplicated target %s", $1);
81	target->t_nickname = $1;	82	target->t_nickname = $1;
82	target = target_new(conf);	83	target = target_new(conf);
83	}	84	}
Lines 127-133 Link Here
127	target_name: TARGET_NAME EQUALS STR	128	target_name: TARGET_NAME EQUALS STR
128	{	129	{
129	if (target->t_name != NULL)	130	if (target->t_name != NULL)
130	errx(1, "duplicated TargetName at line %d", lineno);	131	xo_errx(1, "duplicated TargetName at line %d", lineno);
131	target->t_name = $3;	132	target->t_name = $3;
132	}	133	}
133	;	134	;
Lines 135-141 Link Here
135	target_address: TARGET_ADDRESS EQUALS STR	136	target_address: TARGET_ADDRESS EQUALS STR
136	{	137	{
137	if (target->t_address != NULL)	138	if (target->t_address != NULL)
138	errx(1, "duplicated TargetAddress at line %d", lineno);	139	xo_errx(1, "duplicated TargetAddress at line %d", lineno);
139	target->t_address = $3;	140	target->t_address = $3;
140	}	141	}
141	;	142	;
Lines 143-149 Link Here
143	initiator_name: INITIATOR_NAME EQUALS STR	144	initiator_name: INITIATOR_NAME EQUALS STR
144	{	145	{
145	if (target->t_initiator_name != NULL)	146	if (target->t_initiator_name != NULL)
146	errx(1, "duplicated InitiatorName at line %d", lineno);	147	xo_errx(1, "duplicated InitiatorName at line %d", lineno);
147	target->t_initiator_name = $3;	148	target->t_initiator_name = $3;
148	}	149	}
149	;	150	;
Lines 151-157 Link Here
151	initiator_address: INITIATOR_ADDRESS EQUALS STR	152	initiator_address: INITIATOR_ADDRESS EQUALS STR
152	{	153	{
153	if (target->t_initiator_address != NULL)	154	if (target->t_initiator_address != NULL)
154	errx(1, "duplicated InitiatorAddress at line %d", lineno);	155	xo_errx(1, "duplicated InitiatorAddress at line %d", lineno);
155	target->t_initiator_address = $3;	156	target->t_initiator_address = $3;
156	}	157	}
157	;	158	;
Lines 159-165 Link Here
159	initiator_alias: INITIATOR_ALIAS EQUALS STR	160	initiator_alias: INITIATOR_ALIAS EQUALS STR
160	{	161	{
161	if (target->t_initiator_alias != NULL)	162	if (target->t_initiator_alias != NULL)
162	errx(1, "duplicated InitiatorAlias at line %d", lineno);	163	xo_errx(1, "duplicated InitiatorAlias at line %d", lineno);
163	target->t_initiator_alias = $3;	164	target->t_initiator_alias = $3;
164	}	165	}
165	;	166	;
Lines 167-173 Link Here
167	user: USER EQUALS STR	168	user: USER EQUALS STR
168	{	169	{
169	if (target->t_user != NULL)	170	if (target->t_user != NULL)
170	errx(1, "duplicated chapIName at line %d", lineno);	171	xo_errx(1, "duplicated chapIName at line %d", lineno);
171	target->t_user = $3;	172	target->t_user = $3;
172	}	173	}
173	;	174	;
Lines 175-181 Link Here
175	secret: SECRET EQUALS STR	176	secret: SECRET EQUALS STR
176	{	177	{
177	if (target->t_secret != NULL)	178	if (target->t_secret != NULL)
178	errx(1, "duplicated chapSecret at line %d", lineno);	179	xo_errx(1, "duplicated chapSecret at line %d", lineno);
179	target->t_secret = $3;	180	target->t_secret = $3;
180	}	181	}
181	;	182	;
Lines 183-189 Link Here
183	mutual_user: MUTUAL_USER EQUALS STR	184	mutual_user: MUTUAL_USER EQUALS STR
184	{	185	{
185	if (target->t_mutual_user != NULL)	186	if (target->t_mutual_user != NULL)
186	errx(1, "duplicated tgtChapName at line %d", lineno);	187	xo_errx(1, "duplicated tgtChapName at line %d", lineno);
187	target->t_mutual_user = $3;	188	target->t_mutual_user = $3;
188	}	189	}
189	;	190	;
Lines 191-197 Link Here
191	mutual_secret: MUTUAL_SECRET EQUALS STR	192	mutual_secret: MUTUAL_SECRET EQUALS STR
192	{	193	{
193	if (target->t_mutual_secret != NULL)	194	if (target->t_mutual_secret != NULL)
194	errx(1, "duplicated tgtChapSecret at line %d", lineno);	195	xo_errx(1, "duplicated tgtChapSecret at line %d", lineno);
195	target->t_mutual_secret = $3;	196	target->t_mutual_secret = $3;
196	}	197	}
197	;	198	;
Lines 199-211 Link Here
199	auth_method: AUTH_METHOD EQUALS STR	200	auth_method: AUTH_METHOD EQUALS STR
200	{	201	{
201	if (target->t_auth_method != AUTH_METHOD_UNSPECIFIED)	202	if (target->t_auth_method != AUTH_METHOD_UNSPECIFIED)
202	errx(1, "duplicated AuthMethod at line %d", lineno);	203	xo_errx(1, "duplicated AuthMethod at line %d", lineno);
203	if (strcasecmp($3, "none") == 0)	204	if (strcasecmp($3, "none") == 0)
204	target->t_auth_method = AUTH_METHOD_NONE;	205	target->t_auth_method = AUTH_METHOD_NONE;
205	else if (strcasecmp($3, "chap") == 0)	206	else if (strcasecmp($3, "chap") == 0)
206	target->t_auth_method = AUTH_METHOD_CHAP;	207	target->t_auth_method = AUTH_METHOD_CHAP;
207	else	208	else
208	errx(1, "invalid AuthMethod at line %d; "	209	xo_errx(1, "invalid AuthMethod at line %d; "
209	"must be either \"none\" or \"CHAP\"", lineno);	210	"must be either \"none\" or \"CHAP\"", lineno);
210	}	211	}
211	;	212	;
Lines 213-225 Link Here
213	header_digest: HEADER_DIGEST EQUALS STR	214	header_digest: HEADER_DIGEST EQUALS STR
214	{	215	{
215	if (target->t_header_digest != DIGEST_UNSPECIFIED)	216	if (target->t_header_digest != DIGEST_UNSPECIFIED)
216	errx(1, "duplicated HeaderDigest at line %d", lineno);	217	xo_errx(1, "duplicated HeaderDigest at line %d", lineno);
217	if (strcasecmp($3, "none") == 0)	218	if (strcasecmp($3, "none") == 0)
218	target->t_header_digest = DIGEST_NONE;	219	target->t_header_digest = DIGEST_NONE;
219	else if (strcasecmp($3, "CRC32C") == 0)	220	else if (strcasecmp($3, "CRC32C") == 0)
220	target->t_header_digest = DIGEST_CRC32C;	221	target->t_header_digest = DIGEST_CRC32C;
221	else	222	else
222	errx(1, "invalid HeaderDigest at line %d; "	223	xo_errx(1, "invalid HeaderDigest at line %d; "
223	"must be either \"none\" or \"CRC32C\"", lineno);	224	"must be either \"none\" or \"CRC32C\"", lineno);
224	}	225	}
225	;	226	;
Lines 227-239 Link Here
227	data_digest: DATA_DIGEST EQUALS STR	228	data_digest: DATA_DIGEST EQUALS STR
228	{	229	{
229	if (target->t_data_digest != DIGEST_UNSPECIFIED)	230	if (target->t_data_digest != DIGEST_UNSPECIFIED)
230	errx(1, "duplicated DataDigest at line %d", lineno);	231	xo_errx(1, "duplicated DataDigest at line %d", lineno);
231	if (strcasecmp($3, "none") == 0)	232	if (strcasecmp($3, "none") == 0)
232	target->t_data_digest = DIGEST_NONE;	233	target->t_data_digest = DIGEST_NONE;
233	else if (strcasecmp($3, "CRC32C") == 0)	234	else if (strcasecmp($3, "CRC32C") == 0)
234	target->t_data_digest = DIGEST_CRC32C;	235	target->t_data_digest = DIGEST_CRC32C;
235	else	236	else
236	errx(1, "invalid DataDigest at line %d; "	237	xo_errx(1, "invalid DataDigest at line %d; "
237	"must be either \"none\" or \"CRC32C\"", lineno);	238	"must be either \"none\" or \"CRC32C\"", lineno);
238	}	239	}
239	;	240	;
Lines 241-253 Link Here
241	session_type: SESSION_TYPE EQUALS STR	242	session_type: SESSION_TYPE EQUALS STR
242	{	243	{
243	if (target->t_session_type != SESSION_TYPE_UNSPECIFIED)	244	if (target->t_session_type != SESSION_TYPE_UNSPECIFIED)
244	errx(1, "duplicated SessionType at line %d", lineno);	245	xo_errx(1, "duplicated SessionType at line %d", lineno);
245	if (strcasecmp($3, "normal") == 0)	246	if (strcasecmp($3, "normal") == 0)
246	target->t_session_type = SESSION_TYPE_NORMAL;	247	target->t_session_type = SESSION_TYPE_NORMAL;
247	else if (strcasecmp($3, "discovery") == 0)	248	else if (strcasecmp($3, "discovery") == 0)
248	target->t_session_type = SESSION_TYPE_DISCOVERY;	249	target->t_session_type = SESSION_TYPE_DISCOVERY;
249	else	250	else
250	errx(1, "invalid SessionType at line %d; "	251	xo_errx(1, "invalid SessionType at line %d; "
251	"must be either \"normal\" or \"discovery\"", lineno);	252	"must be either \"normal\" or \"discovery\"", lineno);
252	}	253	}
253	;	254	;
Lines 255-261 Link Here
255	offload: OFFLOAD EQUALS STR	256	offload: OFFLOAD EQUALS STR
256	{	257	{
257	if (target->t_offload != NULL)	258	if (target->t_offload != NULL)
258	errx(1, "duplicated offload at line %d", lineno);	259	xo_errx(1, "duplicated offload at line %d", lineno);
259	target->t_offload = $3;	260	target->t_offload = $3;
260	}	261	}
261	;	262	;
Lines 263-282 Link Here
263	protocol: PROTOCOL EQUALS STR	264	protocol: PROTOCOL EQUALS STR
264	{	265	{
265	if (target->t_protocol != PROTOCOL_UNSPECIFIED)	266	if (target->t_protocol != PROTOCOL_UNSPECIFIED)
266	errx(1, "duplicated protocol at line %d", lineno);	267	xo_errx(1, "duplicated protocol at line %d", lineno);
267	if (strcasecmp($3, "iscsi") == 0)	268	if (strcasecmp($3, "iscsi") == 0)
268	target->t_protocol = PROTOCOL_ISCSI;	269	target->t_protocol = PROTOCOL_ISCSI;
269	else if (strcasecmp($3, "iser") == 0)	270	else if (strcasecmp($3, "iser") == 0)
270	target->t_protocol = PROTOCOL_ISER;	271	target->t_protocol = PROTOCOL_ISER;
271	else	272	else
272	errx(1, "invalid protocol at line %d; "	273	xo_errx(1, "invalid protocol at line %d; "
273	"must be either \"iscsi\" or \"iser\"", lineno);	274	"must be either \"iscsi\" or \"iser\"", lineno);
274	}	275	}
275	;	276	;
276		277
277	ignored: IGNORED EQUALS STR	278	ignored: IGNORED EQUALS STR
278	{	279	{
279	warnx("obsolete statement ignored at line %d", lineno);	280	xo_warnx("obsolete statement ignored at line %d", lineno);
280	}	281	}
281	;	282	;
282		283
Lines 286-292 Link Here
286	yyerror(const char *str)	287	yyerror(const char *str)
287	{	288	{
288		289
289	errx(1, "error in configuration file at line %d near '%s': %s",	290	xo_errx(1, "error in configuration file at line %d near '%s': %s",
290	lineno, yytext, str);	291	lineno, yytext, str);
291	}	292	}
292		293
Lines 298-316 Link Here
298		299
299	error = stat(path, &sb);	300	error = stat(path, &sb);
300	if (error != 0) {	301	if (error != 0) {
301	warn("stat");	302	xo_warn("stat");
302	return;	303	return;
303	}	304	}
304	if (sb.st_mode & S_IWOTH) {	305	if (sb.st_mode & S_IWOTH) {
305	warnx("%s is world-writable", path);	306	xo_warnx("%s is world-writable", path);
306	} else if (sb.st_mode & S_IROTH) {	307	} else if (sb.st_mode & S_IROTH) {
307	warnx("%s is world-readable", path);	308	xo_warnx("%s is world-readable", path);
308	} else if (sb.st_mode & S_IXOTH) {	309	} else if (sb.st_mode & S_IXOTH) {
309	/*	310	/*
310	* Ok, this one doesn't matter, but still do it,	311	* Ok, this one doesn't matter, but still do it,
311	* just for consistency.	312	* just for consistency.
312	*/	313	*/
313	warnx("%s is world-executable", path);	314	xo_warnx("%s is world-executable", path);
314	}	315	}
315		316
316	/*	317	/*