path: root/usr/src/common/iscsi/utils.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <sys/types.h>
#include <sys/socket.h>


#ifdef _KERNEL
#include <sys/sunddi.h>
#else
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <ctype.h>
#include <netinet/in.h>
#include <sys/utsname.h>

/*
 * NOTE: This routine is found in libnsl. There's apparently no prototype to
 * be found in any of the header files in /usr/include so defining a prototype
 * here to keep the compiler happy.
 */
int getdomainname(char *, int);

static const char *iqn_template		= "iqn.2004-02.%s";
#endif

#include <sys/scsi/adapters/iscsi_if.h>

typedef struct utils_val_name {
	int	u_val;
	char	*u_name;
} utils_val_name_t;

utils_val_name_t param_names[] = {
	{ ISCSI_LOGIN_PARAM_DATA_SEQUENCE_IN_ORDER, "Sequence In Order"},
	{ ISCSI_LOGIN_PARAM_IMMEDIATE_DATA, "Immediate Data"},
	{ ISCSI_LOGIN_PARAM_INITIAL_R2T, "Inital R2T"},
	{ ISCSI_LOGIN_PARAM_DATA_PDU_IN_ORDER, "Data PDU In Order"},
	{ ISCSI_LOGIN_PARAM_HEADER_DIGEST, "Header Digest"},
	{ ISCSI_LOGIN_PARAM_DATA_DIGEST, "Data Digest"},
	{ ISCSI_LOGIN_PARAM_DEFAULT_TIME_2_RETAIN, "Default Time To Retain"},
	{ ISCSI_LOGIN_PARAM_DEFAULT_TIME_2_WAIT, "Default Time To Wait"},
	{ ISCSI_LOGIN_PARAM_MAX_RECV_DATA_SEGMENT_LENGTH,
	    "Max Recv Data Segment Length"},
	{ ISCSI_LOGIN_PARAM_FIRST_BURST_LENGTH, "First Burst Length"},
	{ ISCSI_LOGIN_PARAM_MAX_BURST_LENGTH, "Max Burst Length"},
	{ ISCSI_LOGIN_PARAM_MAX_CONNECTIONS, "Max Connections"},
	{ ISCSI_LOGIN_PARAM_OUTSTANDING_R2T, "Outstanding R2T"},
	{ ISCSI_LOGIN_PARAM_ERROR_RECOVERY_LEVEL, "Error Recovery Level"},
	{ 0, NULL }
};

/*
 * utils_map_param -- Given a parameter return it's ascii name
 *
 * This routine was created because previously an array contained in order
 * the parameter names. Once or twice the parameters value changed which
 * changed the order, but not the array. To avoid further confusion we'll
 * do a simple lookup. This code is rarely called so it shouldn't be an
 * issue.
 */
char *
utils_map_param(int p)
{
	utils_val_name_t	*pn;

	for (pn = param_names; pn->u_name != NULL; pn++)
		if (pn->u_val == p)
			return (pn->u_name);
	return (NULL);
}

/*
 * prt_bitmap -- print out ascii strings associated with bit numbers.
 */
char *
prt_bitmap(int bitmap, char *str, char *buf, int size)
{
	char	*p		= NULL;
	char	*start		= buf;
	int	do_put		= 0;

	/*
	 * The maximum space required will if the bitmap was all 1's which
	 * would cause the octal characters to be replaced by '|'. So make
	 * sure the buffer has enough space.
	 */
	if (size < strlen(str))
		return ("No room");

	for (p = str; size--; p++) {
		if (*p < 0x20) {

			/*
			 * if we have been putting out stuff add separator
			 */
			if (do_put)
				*buf++ = '|';

			do_put = ((1 << *p) & bitmap);
			bitmap &= ~(1 << *p);

		} else if (do_put)
			*buf++ = *p;
	}

	/* ---- remove the last separator if it was added ---- */
	if ((buf > start) && (*(buf - 1) == '|'))
		buf--;
	*buf = '\0';
	return (start);
}

/*
 * parse_addr_port_tpgt - Used to parse addr, port and tpgt from string
 *
 * This function is used to parse addr, port and tpgt from a string.  Callers
 * of this function are the sendtargets and login redirection code.  The
 * caller must be aware that this function will modify the callers string
 * to insert NULL terminators if required.  Port and TPGT are optional.
 */
boolean_t
parse_addr_port_tpgt(char *in, char **addr, int *type, char **port, char **tpgt)
{
	char	*t_port, *t_tpgt;

	/* default return values if requested */
	if (addr == NULL) {
		return (B_FALSE);
	} else {
		*addr = NULL;
	}
	if (port != NULL) {
		*port = NULL;
	}
	if (tpgt != NULL) {
		*tpgt = NULL;
	}

	/* extract ip or domain name */
	if (*in == '[') {
		/* IPV6 */
		*type = AF_INET6;
		*addr = ++in;
		in = strchr(*addr, ']');
		if (in == NULL)
			return (B_FALSE);
		*in++ = '\0';
	} else {
		/* IPV4 or domainname */
		*type = AF_INET;
		*addr = in;
	}

	/* extract port */
	if (port != NULL) {
		t_port = strchr(in, ':');
		if (t_port != NULL) {
			*t_port++ = '\0';
			*port = in = t_port;
		}
	}

	/* exact tpgt */
	if (tpgt != NULL) {
		t_tpgt = strchr(in, ',');
		if (t_tpgt != NULL) {
			*t_tpgt++ = '\0';
			*tpgt = in = t_tpgt;
		}
	}

	return (B_TRUE);
}

#ifndef _KERNEL
/*
 * []--------------------------------------------------------------[]
 * | reverse_fqdn -- given a fully qualified domain name reverse it |
 * |                                                                |
 * | The routine has the obvious problem that it can only handle a  |
 * | name with 5 or less dots. This needs to be fixed by counting   |
 * | the number of dots in the incoming name, calloc'ing an array   |
 * | of the appropriate size and then handling the pointers.	    |
 * []--------------------------------------------------------------[]
 */
static boolean_t
/* LINTED E_FUNC_ARG_UNUSED for 3rd arg size */
reverse_fqdn(const char *domain, char *buf, int size)
{
	char	*ptrs[5];
	char	*dp;
	char	*dp1;
	char	*p;
	int	v = 4;

	if ((dp = dp1 = malloc(strlen(domain) + 1)) == NULL)
		return (B_FALSE);
	(void) strcpy(dp, domain);
	while ((p = (char *)strchr(dp, '.')) != NULL) {
		*p = '\0';
		if (v < 0) {
			free(dp1);
			return (B_FALSE);
		}
		ptrs[v--] = dp;
		dp = p + 1;
	}
	(void) strcpy(buf, dp);
	for (v++; v < 5; v++) {
		(void) strcat(buf, ".");
		(void) strcat(buf, ptrs[v]);
	}
	free(dp1);
	return (B_TRUE);
}

/*
 * []------------------------------------------------------------------[]
 * | utils_iqn_create -- returns an iqn name for the machine		|
 * |									|
 * | The information found in the iqn is not correct. The year and	|
 * | date should be flexible. Currently this is hardwired to the	|
 * | current year and month of this project.				|
 * []------------------------------------------------------------------[]
 */
boolean_t
utils_iqn_create(char *iqn_buf, int size)
{
	struct utsname	uts_info;
	char		domainname[256];
	char		*temp = NULL;
	char		*p;
	char		*pmet = NULL; /* temp reversed .. get it */
	int		len;
	boolean_t	rval = B_FALSE; /* Default */

	if (uname(&uts_info) == -1) {
		goto out;
	}

	if (getdomainname(domainname, sizeof (domainname))) {
		goto out;
	}

	if ((temp = malloc(strlen(uts_info.nodename) +
	    strlen(domainname) + 2)) == NULL) {
		goto out;
	}

	/*
	 * getdomainname always returns something in the order of
	 * host.domainname so we need to skip over that portion of the
	 * host name because we don't care about it.
	 */
	if ((p = strchr(domainname, '.')) == NULL)
		p = domainname;
	else
		p++;

	/* ---- Create Fully Qualified Domain Name ---- */
	(void) snprintf(temp, strlen(p), "%s.%s", uts_info.nodename, p);

	/* ---- According to the spec, names must be lower case ---- */
	for (p = temp; *p; p++)
		if (isupper(*p))
			*p = tolower(*p);

	len = strlen(temp) + 1;
	if ((pmet = malloc(len)) == NULL) {
		goto out;
	}

	if (reverse_fqdn(temp, pmet, len) == B_FALSE) {
		goto out;
	}

	/*
	 * Now use the template with the reversed domainname to create
	 * an iSCSI name using the IQN format. Only count it a success
	 * if the number of characters formated is less than the buffer
	 * size.
	 */
	if (snprintf(iqn_buf, size, iqn_template, pmet) <= size)
		rval = B_TRUE;
out:
	if (temp)
		free(temp);
	if (pmet)
		free(pmet);

	return (rval);
}
#endif /* !_KERNEL */