export.c

/*
 * Helper functions to represent iSNS objects as text,
 * and/or to parse objects represented in textual form.
 * These functions can be used by command line utilities
 * such as isnsadm, as well as applications like iscsid
 * or stgtd when talking to the iSNS discovery daemon.
 *
 * Copyright (C) 2007 Olaf Kirch <olaf.kirch@oracle.com>
 */

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <ctype.h>

#include "config.h"
#include <libisns/isns.h>
#include <libisns/util.h>
#include "vendor.h"
#include <libisns/attrs.h>
#include "security.h"
#include "objects.h"
#include <libisns/paths.h>

#define MAX_ALIASES		4

struct isns_tag_prefix {
	const char *		name;
	unsigned int		name_len;
	isns_object_template_t *context;
};

struct tag_name {
	const char *		name;
	uint32_t		tag;
	struct isns_tag_prefix *prefix;
	const char *		alias[MAX_ALIASES];
};

static struct isns_tag_prefix all_prefixes[__ISNS_OBJECT_TYPE_MAX] = {
[ISNS_OBJECT_TYPE_ENTITY] = { "entity-", 7, &isns_entity_template	},
[ISNS_OBJECT_TYPE_NODE]   = { "iscsi-",	 6, &isns_iscsi_node_template	},
[ISNS_OBJECT_TYPE_PORTAL] = { "portal-", 7, &isns_portal_template	},
[ISNS_OBJECT_TYPE_PG]     = { "pg-",	 3, &isns_iscsi_pg_template	},
[ISNS_OBJECT_TYPE_DD]     = { "dd-",	 3, &isns_dd_template		},
[ISNS_OBJECT_TYPE_POLICY] = { "policy-", 7, &isns_policy_template	},
};

static struct tag_name	all_attrs[] = {
{ "id",			ISNS_TAG_ENTITY_IDENTIFIER,
			.alias = { "eid", },
},
{ "prot",		ISNS_TAG_ENTITY_PROTOCOL },
{ "idx",		ISNS_TAG_ENTITY_INDEX },

{ "name",		ISNS_TAG_ISCSI_NAME },
{ "node-type",		ISNS_TAG_ISCSI_NODE_TYPE },
{ "alias",		ISNS_TAG_ISCSI_ALIAS },
{ "authmethod",		ISNS_TAG_ISCSI_AUTHMETHOD },
{ "idx",		ISNS_TAG_ISCSI_NODE_INDEX },

{ "addr",		ISNS_TAG_PORTAL_IP_ADDRESS },
{ "port",		ISNS_TAG_PORTAL_TCP_UDP_PORT },
{ "name",		ISNS_TAG_PORTAL_SYMBOLIC_NAME },
{ "esi-port",		ISNS_TAG_ESI_PORT },
{ "esi-interval",	ISNS_TAG_ESI_INTERVAL },
{ "scn-port",		ISNS_TAG_SCN_PORT },
{ "idx",		ISNS_TAG_PORTAL_INDEX },

{ "name",		ISNS_TAG_PG_ISCSI_NAME },
{ "addr",		ISNS_TAG_PG_PORTAL_IP_ADDR },
{ "port",		ISNS_TAG_PG_PORTAL_TCP_UDP_PORT },
{ "tag",		ISNS_TAG_PG_TAG },
{ "pgt",		ISNS_TAG_PG_TAG },
{ "idx",		ISNS_TAG_PG_INDEX },

{ "id",			ISNS_TAG_DD_ID },
{ "name",		ISNS_TAG_DD_SYMBOLIC_NAME },
{ "member-name",	ISNS_TAG_DD_MEMBER_ISCSI_NAME },
{ "member-iscsi-idx",	ISNS_TAG_DD_MEMBER_ISCSI_INDEX },
{ "member-fc-name",	ISNS_TAG_DD_MEMBER_FC_PORT_NAME },
{ "member-portal-idx",	ISNS_TAG_DD_MEMBER_PORTAL_INDEX },
{ "member-addr",	ISNS_TAG_DD_MEMBER_PORTAL_IP_ADDR  },
{ "member-port",	ISNS_TAG_DD_MEMBER_PORTAL_TCP_UDP_PORT  },
{ "features",		ISNS_TAG_DD_FEATURES },

{ "name",		OPENISNS_TAG_POLICY_SPI,
			.alias = { "spi" },
},
{ "key",		OPENISNS_TAG_POLICY_KEY },
{ "entity",		OPENISNS_TAG_POLICY_ENTITY },
{ "object-type",	OPENISNS_TAG_POLICY_OBJECT_TYPE },
{ "node-type",		OPENISNS_TAG_POLICY_NODE_TYPE },
{ "node-name",		OPENISNS_TAG_POLICY_NODE_NAME },
{ "functions",		OPENISNS_TAG_POLICY_FUNCTIONS },

{ NULL }
};

/*
 * Initialize tag array
 */
static void
init_tags(void)
{
	struct tag_name	*t;

	for (t = all_attrs; t->name; ++t) {
		isns_object_template_t *tmpl;

		tmpl = isns_object_template_for_tag(t->tag);
		if (tmpl == NULL)
			isns_fatal("Bug: cannot find object type for tag %s\n",
					t->name);
		t->prefix = &all_prefixes[tmpl->iot_handle];
	}
}

/*
 * Match prefix
 */
static struct isns_tag_prefix *
find_prefix(const char *name)
{
	struct isns_tag_prefix *p;
	unsigned int	i;

	for (i = 0, p = all_prefixes; i < __ISNS_OBJECT_TYPE_MAX; ++i, ++p) {
		if (p->name && !strncmp(name, p->name, p->name_len))
			return p;
	}
	return NULL;
}

/*
 * Look up the tag for a given attribute name.
 * By default, attr names come with a disambiguating
 * prefix that defines the object type the attribute applies
 * to, such as "entity-" or "portal-". Once a context has
 * been established (ie we know the object type subsequent
 * attributes apply to), specifying the prefix is optional.
 *
 * For instance, in a portal context, "addr=10.1.1.1 port=616 name=foo"
 * specifies three portal related attributes. Whereas in a portal
 * group context, the same string would specify three portal group
 * related attributes. To disambiguate, the first attribute in
 * this list should be prefixed by "portal-" or "pg-", respectively.
 */
static uint32_t
tag_by_name(const char *name, struct isns_attr_list_parser *st)
{
	const char	*orig_name = name;
	unsigned int	nmatch = 0, i;
	struct tag_name	*t, *match[8];
	struct isns_tag_prefix *specific = NULL;

	if (all_attrs[0].prefix == NULL)
		init_tags();

	specific = find_prefix(name);
	if (specific != NULL) {
		if (st->prefix
		 && st->prefix != specific
		 && !st->multi_type_permitted) {
			isns_error("Cannot mix attributes of different types\n");
			return 0;
		}
		name += specific->name_len;
		st->prefix = specific;
	}

	for (t = all_attrs; t->name; ++t) {
		if (specific && t->prefix != specific)
			continue;
		if (!st->multi_type_permitted
		 && st->prefix && t->prefix != st->prefix)
			continue;
		if (!strcmp(name, t->name))
			goto match;
		for (i = 0; i < MAX_ALIASES && t->alias[i]; ++i) {
			if (!strcmp(name, t->alias[i]))
				goto match;
		}
		continue;

match:
		if (nmatch < 8)
			match[nmatch++] = t;
	}

	if (nmatch > 1) {
		char		conflict[128];
		unsigned int	i;

		conflict[0] = '\0';
		for (i = 0; i < nmatch; ++i) {
			if (i)
				strcat(conflict, ", ");
			t = match[i];
			strcat(conflict, t->prefix->name);
			strcat(conflict, t->name);
		}
		isns_error("tag name \"%s\" not unique in this context "
				"(could be one of %s)\n",
				orig_name, conflict);
		return 0;
	}

	if (nmatch == 0) {
		isns_error("tag name \"%s\" not known in this context\n",
				orig_name);
		return 0;
	}

	st->prefix = match[0]->prefix;
	return match[0]->tag;
}

static const char *
name_by_tag(uint32_t tag, struct isns_attr_list_parser *st)
{
	struct tag_name *t;

	for (t = all_attrs; t->name; ++t) {
		if (st->prefix && t->prefix != st->prefix)
			continue;
		if (t->tag == tag)
			return t->name;
	}
	return NULL;
}

static int
parse_one_attr(const char *name, const char *value,
		isns_attr_list_t *attrs,
		struct isns_attr_list_parser *st)
{
	isns_attr_t	*attr;
	uint32_t	tag;

	/* Special case: "portal=<address:port>" is translated to
	 * addr=<address> port=<port>
	 * If no context has been set, assume portal context.
	 */
	if (!strcasecmp(name, "portal")) {
		isns_portal_info_t portal_info;
		uint32_t	addr_tag, port_tag;

		if (st->prefix == NULL) {
			addr_tag = tag_by_name("portal-addr", st);
			port_tag = tag_by_name("portal-port", st);
		} else {
			addr_tag = tag_by_name("addr", st);
			port_tag = tag_by_name("port", st);
		}

		if (!addr_tag || !port_tag) {
			isns_error("portal=... not supported in this context\n");
			return 0;
		}
		if (value == NULL) {
			isns_attr_list_append_nil(attrs, addr_tag);
			isns_attr_list_append_nil(attrs, port_tag);
			return 1;
		}
		if (!isns_portal_parse(&portal_info, value, st->default_port))
			return 0;
		isns_portal_to_attr_list(&portal_info, addr_tag, port_tag, attrs);
		return 1;
	}

	if (!(tag = tag_by_name(name, st)))
		return 0;

	/* Special handling for key objects */
	if (tag == OPENISNS_TAG_POLICY_KEY) {
		if (!value || !strcasecmp(value, "gen")) {
			if (st->generate_key == NULL) {
				isns_error("Key generation not supported in this context\n");
				return 0;
			}
			attr = st->generate_key();
		} else {
			if (st->load_key == NULL) {
				isns_error("Policy-key attribute not supported in this context\n");
				return 0;
			}
			attr = st->load_key(value);
		}
		goto append_attr;
	}

	if (value == NULL) {
		isns_attr_list_append_nil(attrs, tag);
		return 1;
	}

	attr = isns_attr_from_string(tag, value);
	if (!attr)
		return 0;

append_attr:
	isns_attr_list_append_attr(attrs, attr);
	return 1;
}

void
isns_attr_list_parser_init(struct isns_attr_list_parser *st,
				isns_object_template_t *tmpl)
{
	if (all_attrs[0].prefix == NULL)
		init_tags();

	memset(st, 0, sizeof(*st));
	if (tmpl)
		st->prefix = &all_prefixes[tmpl->iot_handle];
}

int
isns_attr_list_split(char *line, char **argv, unsigned int argc_max)
{
	char		*src = line;
	unsigned int	argc = 0, quoted = 0;

	if (!line)
		return 0;

	while (1) {
		char	*dst;

		while (isspace(*src))
			++src;
		if (!*src)
			break;

		argv[argc] = dst = src;
		while (*src) {
			char cc = *src++;

			if (cc == '"') {
				quoted = !quoted;
				continue;
			}
			if (!quoted && isspace(cc)) {
				*dst = '\0';
				break;
			}
			*dst++ = cc;
		}

		if (quoted) {
			isns_error("%s: Unterminated quoted string: \"%s\"\n",
					__FUNCTION__, argv[argc]);
			return -1;
		}
		argc++;
	}

	return argc;
}

int
isns_parse_attrs(unsigned int argc, char **argv,
		isns_attr_list_t *attrs,
		struct isns_attr_list_parser *st)
{
	unsigned int	i;

	for (i = 0; i < argc; ++i) {
		char		*name, *value;

		name = argv[i];
		if ((value = strchr(name, '=')) != NULL)
			*value++ = '\0';

		if (!value && !st->nil_permitted) {
			isns_error("Missing value for atribute %s\n", name);
			return 0;
		}

		if (!parse_one_attr(name, value, attrs, st)) {
			isns_error("Unable to parse %s=%s\n", name, value);
			return 0;
		}
	}

	return 1;
}

/*
 * Query strings may contain a mix of query keys (foo=bar),
 * and requested attributes (?foo). The former are used by
 * the server in its object search, whereas the latter instruct
 * it which attributes to return.
 */
int
isns_parse_query_attrs(unsigned int argc, char **argv,
		isns_attr_list_t *keys,
		isns_attr_list_t *requested_attrs,
		struct isns_attr_list_parser *st)
{
	struct isns_attr_list_parser query_state;
	unsigned int	i;

	query_state = *st;
	query_state.multi_type_permitted = 1;

	for (i = 0; i < argc; ++i) {
		char		*name, *value;

		name = argv[i];
		if ((value = strchr(name, '=')) != NULL)
			*value++ = '\0';

		if (name[0] == '?') {
			uint32_t tag;

			if (value) {
				isns_error("No value allowed for query attribute %s\n",
						name);
				return 0;
			}

			if ((tag = tag_by_name(name + 1, &query_state)) != 0) {
				isns_attr_list_append_nil(requested_attrs, tag);
				continue;
			}
		} else {
			if (!value && !st->nil_permitted) {
				isns_error("Missing value for atribute %s\n", name);
				return 0;
			}

			if (parse_one_attr(name, value, keys, st))
				continue;
		}

		isns_error("Unable to parse %s=%s\n", name, value);
		return 0;
	}

	return 1;
}

void
isns_attr_list_parser_help(struct isns_attr_list_parser *st)
{
	isns_object_template_t *tmpl, *current = NULL;
	struct tag_name	*t;

	if (all_attrs[0].prefix == NULL)
		init_tags();

	for (t = all_attrs; t->name; ++t) {
		const isns_tag_type_t *tag_type;
		char		namebuf[64];
		const char	*help;
		unsigned int	i;

		if (st && !st->multi_type_permitted
		 && st->prefix && t->prefix != st->prefix)
			continue;

		tmpl = t->prefix->context;
		if (tmpl != current) {
			printf("\nAttributes for object type %s; using prefix %s\n",
				tmpl->iot_name, t->prefix->name);
			current = tmpl;
		}

		snprintf(namebuf, sizeof(namebuf), "%s%s", t->prefix->name, t->name);
		printf("  %-20s   ", namebuf);

		tag_type = isns_tag_type_by_id(t->tag);
		if (tag_type == NULL) {
			printf("Unknown\n");
			continue;
		}
		printf("%s (%s", tag_type->it_name,
				tag_type->it_type->it_name);

		if (tag_type->it_readonly)
			printf("; readonly");
		if (tag_type->it_multiple)
			printf("; multiple instances");
		printf(")");

		help = NULL;
		if (t->tag == OPENISNS_TAG_POLICY_KEY) {
			help = "name of key file, or \"gen\" for key generation";
		} else
		if (tag_type->it_help)
			help = tag_type->it_help();

		if (help) {
			if (strlen(help) < 20)
				printf(" [%s]", help);
			else
				printf("\n%25s[%s]", "", help);
		}
		printf("\n");

		if (t->alias[0]) {
			printf("%25sAliases:", "");
			for (i = 0; i < MAX_ALIASES && t->alias[i]; ++i)
				printf(" %s", t->alias[i]);
			printf("\n");
		}
	}
}

isns_object_template_t *
isns_attr_list_parser_context(const struct isns_attr_list_parser *st)
{
	if (st->prefix)
		return st->prefix->context;
	return NULL;
}

int
isns_print_attrs(isns_object_t *obj, char **argv, unsigned int argsmax)
{
	struct isns_attr_list_parser st;
	unsigned int	i, argc = 0;

	isns_attr_list_parser_init(&st, obj->ie_template);

	for (i = 0; i < obj->ie_attrs.ial_count; ++i) {
		isns_attr_t *attr = obj->ie_attrs.ial_data[i];
		char		argbuf[512], value[512];
		const char	*name;

		name = name_by_tag(attr->ia_tag_id, &st);
		if (name == NULL)
			continue;
		if (argc + 1 >= argsmax)
			break;

		snprintf(argbuf, sizeof(argbuf), "%s%s=%s",
				st.prefix->name, name,
				isns_attr_print_value(attr, value, sizeof(value)));
		argv[argc++] = isns_strdup(argbuf);
	}

	argv[argc] = NULL;
	return argc;
}