/*
 * 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 <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "isns_server.h"
#include "isns_func.h"
#include "isns_msgq.h"
#include "isns_htab.h"
#include "isns_cache.h"
#include "isns_obj.h"
#include "isns_dd.h"
#include "isns_pdu.h"
#include "isns_qry.h"

/*
 * external variables
 */
extern const int NUM_OF_ATTRS[MAX_OBJ_TYPE_FOR_SIZE];
extern const int UID_ATTR_INDEX[MAX_OBJ_TYPE_FOR_SIZE];
extern const int NUM_OF_CHILD[MAX_OBJ_TYPE];
extern const int TYPE_OF_CHILD[MAX_OBJ_TYPE][MAX_CHILD_TYPE];

/*
 * global variables
 */
const int TAG_RANGE[MAX_OBJ_TYPE][3] = {
	{ 0, 0 },
	{ ENTITY_KEY, LAST_TAG_ENTITY, ENTITY_END },
	{ ISCSI_KEY, LAST_TAG_ISCSI, ISCSI_END },
	{ PORTAL_KEY1, LAST_TAG_PORTAL, PORTAL_END },
	{ PG_KEY1, LAST_TAG_PG, PG_END },
	{ DD_KEY, LAST_TAG_DD, DD_END },
	{ DDS_KEY, LAST_TAG_DDS, DDS_END }
};

/*
 * local variables
 */
typedef int (*qry_func_t)(lookup_ctrl_t *);

/* Edge functions of each adjacent object */
static int qry_c2e(lookup_ctrl_t *);
static int qry_ds2m(lookup_ctrl_t *);
static int qry_slf(lookup_ctrl_t *);
static int qry_e2i(lookup_ctrl_t *);
static int qry_e2p(lookup_ctrl_t *);
static int qry_e2g(lookup_ctrl_t *);
static int qry_i2g(lookup_ctrl_t *);
static int qry_i2d(lookup_ctrl_t *);
static int qry_p2g(lookup_ctrl_t *);
static int qry_g2i(lookup_ctrl_t *);
static int qry_g2p(lookup_ctrl_t *);
static int qry_d2s(lookup_ctrl_t *);

/* The directed cyclic graph of query procedure. */
/* __|____e_________i_________p_________g_________d_________s____ */
/* e | qry_slf...qry_e2i...qry_e2p...qry_e2g...NULL......NULL.... */
/* i | qry_c2e...qry_slf...NULL......qry_i2g...qry_i2d...NULL.... */
/* p | qry_c2e...NULL......qry_slf...qry_p2g...NULL......NULL.... */
/* g | qry_c2e...qry_g2i...qry_g2p...qry_slf...NULL......NULL.... */
/* d | NULL......qry_ds2m..NULL......NULL......qry_slf...qry_d2s. */
/* s | NULL......NULL......NULL......NULL......qry_ds2m..qry_slf. */

/* The type of spanning tree of query graph. */
typedef struct adjvex {
	qry_func_t f;
	isns_type_t t;
	struct adjvex const *v;
} adjvex_t;

/* The solid edges in the spanning tree. */
static const adjvex_t v_slf = { &qry_slf,  0,		NULL };
static const adjvex_t v_c2e = { &qry_c2e,  OBJ_ENTITY,	NULL };
static const adjvex_t v_e2i = { &qry_e2i,  OBJ_ISCSI,	NULL };
static const adjvex_t v_e2p = { &qry_e2p,  OBJ_PORTAL,	NULL };
static const adjvex_t v_e2g = { &qry_e2g,  OBJ_PG,	NULL };
static const adjvex_t v_i2g = { &qry_i2g,  OBJ_PG,	NULL };
static const adjvex_t v_i2d = { &qry_i2d,  OBJ_DD,	NULL };
static const adjvex_t v_p2g = { &qry_p2g,  OBJ_PG,	NULL };
static const adjvex_t v_g2i = { &qry_g2i,  OBJ_ISCSI,	NULL };
static const adjvex_t v_g2p = { &qry_g2p,  OBJ_PORTAL,	NULL };
static const adjvex_t v_d2s = { &qry_d2s,  OBJ_DDS,	NULL };
static const adjvex_t v_d2i = { &qry_ds2m, OBJ_ISCSI,	NULL };
static const adjvex_t v_s2d = { &qry_ds2m, OBJ_DD,	NULL };

/* The virtual edges in the spanning tree. */
static const adjvex_t v_i2p = { &qry_i2g,  OBJ_PG,    &v_g2p };
static const adjvex_t v_i2s = { &qry_i2d,  OBJ_DD,    &v_d2s };

static const adjvex_t v_g2d = { &qry_g2i,  OBJ_ISCSI, &v_i2d };
static const adjvex_t v_g2s = { &qry_g2i,  OBJ_ISCSI, &v_i2s };

static const adjvex_t v_p2i = { &qry_p2g,  OBJ_PG,    &v_g2i };
static const adjvex_t v_p2d = { &qry_p2g,  OBJ_PG,    &v_g2d };
static const adjvex_t v_p2s = { &qry_p2g,  OBJ_PG,    &v_g2s };

static const adjvex_t v_e2d = { &qry_e2i,  OBJ_ISCSI, &v_i2d };
static const adjvex_t v_e2s = { &qry_e2i,  OBJ_ISCSI, &v_i2s };

static const adjvex_t v_d2e = { &qry_ds2m, OBJ_ISCSI, &v_c2e };
static const adjvex_t v_d2p = { &qry_ds2m, OBJ_ISCSI, &v_i2p };
static const adjvex_t v_d2g = { &qry_ds2m, OBJ_ISCSI, &v_i2g };

static const adjvex_t v_s2e = { &qry_ds2m, OBJ_DD,    &v_d2e };
static const adjvex_t v_s2i = { &qry_ds2m, OBJ_DD,    &v_d2i };
static const adjvex_t v_s2p = { &qry_ds2m, OBJ_DD,    &v_d2p };
static const adjvex_t v_s2g = { &qry_ds2m, OBJ_DD,    &v_d2g };

/* the vector of query graph */
static const adjvex_t *qry_puzzle[MAX_OBJ_TYPE][MAX_OBJ_TYPE] = {
{ NULL },
{ NULL, &v_slf, &v_e2i, &v_e2p, &v_e2g, &v_e2d, &v_e2s },
{ NULL, &v_c2e, &v_slf, &v_i2p, &v_i2g, &v_i2d, &v_i2s },
{ NULL, &v_c2e, &v_p2i, &v_slf, &v_p2g, &v_p2d, &v_p2s },
{ NULL, &v_c2e, &v_g2i, &v_g2p, &v_slf, &v_g2d, &v_g2s },
{ NULL, &v_d2e, &v_d2i, &v_d2p, &v_d2g, &v_slf, &v_d2s },
{ NULL, &v_s2e, &v_s2i, &v_s2p, &v_s2g, &v_s2d, &v_slf }
};

static int
cb_qry_parent_uid(
	void *p1,
	/* LINTED E_FUNC_ARG_UNUSED */
	void *p2
)
{
	uint32_t puid = get_parent_uid((isns_obj_t *)p1);
	return ((int)puid);
}

static int
cb_qry_child_uids(
	void *p1,
	void *p2
)
{
	isns_obj_t *obj = (isns_obj_t *)p1;
	lookup_ctrl_t *lcp = (lookup_ctrl_t *)p2;
	isns_type_t type = lcp->data[1].ui;
	uint32_t *uidp = get_child_t(obj, type);
	uint32_t num = 0;
	uint32_t *p;

	if (uidp != NULL && *uidp > 0) {
		num = *uidp;
		p = malloc(num * sizeof (*p));
		if (p != NULL) {
			uidp ++;
			(void) memcpy(p, uidp, num * sizeof (*p));
			lcp->id[2] = num;
			lcp->data[2].ptr = (uchar_t *)p;
		} else {
			return (ISNS_RSP_INTERNAL_ERROR);
		}
	}

	return (0);
}

static int
e2c(
	lookup_ctrl_t *lcp,
	isns_type_t type
)
{
	int ec = 0;

	uint32_t uid = lcp->curr_uid; /* last child */
	uint32_t num_of_child;
	uint32_t *uids;

	uint32_t tmp_uid = 0;

	/* the first times of query */
	if (uid == 0) {
		lcp->data[1].ui = type;
		ec = cache_lookup(lcp, NULL, cb_qry_child_uids);
	}

	num_of_child = lcp->id[2];
	uids = (uint32_t *)lcp->data[2].ptr;

	while (num_of_child > 0) {
		if (*uids > uid) {
			tmp_uid = *uids;
			break;
		}
		uids ++;
		num_of_child --;
	}

	uid = tmp_uid;

	/* no more child, clean up memory */
	if (uid == 0) {
		lcp->data[1].ui = 0;
		lcp->id[2] = 0;
		lcp->data[2].ptr = NULL;

		/* free up the memory */
		free(uids);
	}

	/* save it for returning and querying next uid */
	lcp->curr_uid = uid;

	return (ec);
}

static int
qry_c2e(
	lookup_ctrl_t *lcp
)
{
	uint32_t uid;

	/* child object has only one parent */
	if (lcp->curr_uid == 0) {
		uid = (uint32_t)cache_lookup(lcp, NULL,
		    cb_qry_parent_uid);
	} else {
		uid = 0;
	}

	/* save the result for returnning */
	lcp->curr_uid = uid;

	return (0);
}

static int
qry_ds2m(
	lookup_ctrl_t *lcp
)
{
	int ec = 0;

	uint32_t uid = lcp->curr_uid; /* last member */
	isns_type_t type = lcp->type;
	uint32_t ds_id = lcp->data[0].ui;

	uint32_t tmp_uid;

	uint32_t n;
	bmp_t *p;

	/* the first times of query */
	if (uid == 0) {
		ec = (type == OBJ_DD) ?
		    get_dd_matrix(ds_id, &p, &n) :
		    get_dds_matrix(ds_id, &p, &n);
		lcp->id[1] = n;
		lcp->data[1].ptr = (uchar_t *)p;
	} else {
		n = lcp->id[1];
		p = (bmp_t *)lcp->data[1].ptr;
	}

	FOR_EACH_MEMBER(p, n, tmp_uid, {
		if (tmp_uid > uid) {
			lcp->curr_uid = tmp_uid;
			return (ec);
		}
	});

	/* no more member, clean up memory */
	lcp->id[1] = 0;
	lcp->data[1].ptr = NULL;

	/* free up the matrix */
	free(p);

	lcp->curr_uid = 0;

	return (ec);
}

static int
qry_slf(
	lookup_ctrl_t *lcp
)
{
	uint32_t uid;

	if (lcp->curr_uid == 0) {
		uid = lcp->data[0].ui;
	} else {
		uid = 0;
	}

	lcp->curr_uid = uid;

	return (0);
}

static int
qry_e2i(
	lookup_ctrl_t *lcp
)
{
	return (e2c(lcp, OBJ_ISCSI));
}

static int
qry_e2p(
	lookup_ctrl_t *lcp
)
{
	return (e2c(lcp, OBJ_PORTAL));
}

static int
qry_e2g(
	lookup_ctrl_t *lcp
)
{
	uint32_t uid = lcp->curr_uid; /* last pg */

	htab_t *htab = cache_get_htab(OBJ_PG);

	lookup_ctrl_t lc;
	uint32_t puid;

	SET_UID_LCP(&lc, OBJ_PG, 0);

	/* this is a shortcut */
	FOR_EACH_ITEM(htab, uid, {
		lc.data[0].ui = uid;
		puid = (uint32_t)cache_lookup(&lc, NULL,
		    cb_qry_parent_uid);
		if (puid == lcp->data[0].ui) {
			/* keep the current uid */
			lcp->curr_uid = uid;
			return (0);
		}
	});

	lcp->curr_uid = 0;

	return (0);
}

static int
qry_i2g(
	lookup_ctrl_t *lcp
)
{
	int ec = 0;

	uint32_t uid = lcp->curr_uid; /* last pg */
	lookup_ctrl_t lc;

	/* the first times of query */
	if (uid == 0) {
		lcp->id[1] = ISNS_ISCSI_NAME_ATTR_ID;
		ec = cache_lookup(lcp, NULL, cb_clone_attrs);
	}

	if (lcp->data[1].ptr != NULL) {
		/* pg lookup */
		lc.curr_uid = uid;
		lc.type = OBJ_PG;
		lc.id[0] = ATTR_INDEX_PG(ISNS_PG_ISCSI_NAME_ATTR_ID);
		lc.op[0] = OP_STRING;
		lc.data[0].ptr = lcp->data[1].ptr;
		lc.op[1] = 0;

		uid = is_obj_there(&lc);
	} else {
		uid = 0;
	}

	/* no more pg, update lcp with pg object */
	if (uid == 0) {
		lcp->id[1] = 0;

		/* clean up the memory */
		if (lcp->data[1].ptr != NULL) {
			free(lcp->data[1].ptr);
			/* reset it */
			lcp->data[1].ptr = NULL;
		}
	}

	/* save it for returning and querying next pg */
	lcp->curr_uid = uid;

	return (ec);
}

static int
qry_i2d(
	lookup_ctrl_t *lcp
)
{
	uint32_t dd_id = lcp->curr_uid; /* last dd_id */
	uint32_t uid = lcp->data[0].ui;

	dd_id = get_dd_id(uid, dd_id);

	/* save it for returning and getting next dd */
	lcp->curr_uid = dd_id;

	return (0);
}

static int
qry_p2g(
	lookup_ctrl_t *lcp
)
{
	int ec = 0;

	uint32_t uid = lcp->curr_uid; /* last pg */
	lookup_ctrl_t lc;

	/* the first time of query */
	if (uid == 0) {
		/* use 1&2 for the portal ip address & port */
		lcp->id[1] = ISNS_PORTAL_IP_ADDR_ATTR_ID;
		lcp->id[2] = ISNS_PORTAL_PORT_ATTR_ID;
		ec = cache_lookup(lcp, NULL, cb_clone_attrs);
	}

	if (lcp->data[1].ip != NULL) {
		/* pg lookup */
		lc.curr_uid = uid;
		lc.type = OBJ_PG;
		lc.id[0] = ATTR_INDEX_PG(ISNS_PG_PORTAL_IP_ADDR_ATTR_ID);
		lc.op[0] = OP_MEMORY_IP6;
		lc.data[0].ip = lcp->data[1].ip;
		lc.id[1] = ATTR_INDEX_PG(ISNS_PG_PORTAL_PORT_ATTR_ID);
		lc.op[1] = OP_INTEGER;
		lc.data[1].ui = lcp->data[2].ui;
		lc.op[2] = 0;

		uid = is_obj_there(&lc);
	} else {
		uid = 0;
	}

	/* no more pg, clean up memory */
	if (uid == 0) {
		lcp->id[1] = 0;
		lcp->id[2] = 0;

		/* clean up the memory */
		if (lcp->data[1].ip != NULL) {
			free(lcp->data[1].ip);
			/* reset it */
			lcp->data[1].ip = NULL;
		}
		lcp->data[2].ui = 0;
	}

	/* save it for returning and next query */
	lcp->curr_uid = uid;

	return (ec);
}

static int
qry_g2i(
	lookup_ctrl_t *lcp
)
{
	int ec = 0;

	uint32_t uid = lcp->curr_uid; /* last node */
	lookup_ctrl_t lc;

	/* the first time of query */
	if (uid == 0) {
		/* use slot 1 for the storage node name */
		lcp->id[1] = ISNS_PG_ISCSI_NAME_ATTR_ID;
		ec = cache_lookup(lcp, NULL, cb_clone_attrs);

		if (lcp->data[1].ptr != NULL) {
			/* iscsi node lookup */
			lc.curr_uid = uid;
			lc.type = OBJ_ISCSI;
			lc.id[0] = ATTR_INDEX_ISCSI(ISNS_ISCSI_NAME_ATTR_ID);
			lc.op[0] = OP_STRING;
			lc.data[0].ptr = lcp->data[1].ptr;
			lc.op[1] = 0;

			uid = is_obj_there(&lc);

			/* no longer need it, clean it up */
			free(lcp->data[1].ptr);
			lcp->data[1].ptr = NULL;
		}
		/* no longer need it, reset it */
		lcp->id[1] = 0;
	} else {
		/* one pg has maximum number of one storage node */
		uid = 0;
	}

	/* save it for returning and next query */
	lcp->curr_uid = uid;

	return (ec);
}

static int
qry_g2p(
	lookup_ctrl_t *lcp
)
{
	int ec = 0;

	uint32_t uid = lcp->curr_uid; /* last portal */
	lookup_ctrl_t lc;

	/* the first times of query */
	if (uid == 0) {
		/* use 1&2 for the portal ip addr and port */
		lcp->id[1] = ISNS_PG_PORTAL_IP_ADDR_ATTR_ID;
		lcp->id[2] = ISNS_PG_PORTAL_PORT_ATTR_ID;
		ec = cache_lookup(lcp, NULL, cb_clone_attrs);

		if (lcp->data[1].ip != NULL) {
			/* portal lookup */
			lc.curr_uid = uid;
			lc.type = OBJ_PORTAL;
			lc.id[0] = ATTR_INDEX_PORTAL(
			    ISNS_PORTAL_IP_ADDR_ATTR_ID);
			lc.op[0] = OP_MEMORY_IP6;
			lc.data[0].ip = lcp->data[1].ip;
			lc.id[1] = ATTR_INDEX_PORTAL(
			    ISNS_PORTAL_PORT_ATTR_ID);
			lc.op[1] = OP_INTEGER;
			lc.data[1].ui = lcp->data[2].ui;
			lc.op[2] = 0;

			uid = is_obj_there(&lc);

			/* no longer need it, reset it */
			free(lcp->data[1].ip);
			lcp->data[1].ip = NULL;
		}
		/* no longer need it, reset it */
		lcp->id[1] = 0;
		lcp->id[2] = 0;
		lcp->data[2].ui = 0;
	} else {
		/* one pg has maximum number of one portal */
		uid = 0;
	}

	/* save it for returning and next query */
	lcp->curr_uid = uid;

	return (ec);
}

static int
qry_d2s(
	lookup_ctrl_t *lcp
)
{
	uint32_t dds_id = lcp->curr_uid; /* last dds */
	uint32_t dd_id = lcp->data[0].ui;

	dds_id = get_dds_id(dd_id, dds_id);

	/* save it for returning and for getting next dds */
	lcp->curr_uid = dds_id;

	return (0);
}

int
validate_qry_key(
	isns_type_t type,
	isns_tlv_t *key,
	uint16_t key_len,
	isns_attr_t *attrs
)
{
	int ec = 0;

	uint32_t tag;
	uint32_t min_tag, max_tag;

	isns_attr_t *attr;

	min_tag = TAG_RANGE[type][0];
	max_tag = TAG_RANGE[type][2];

	while (key_len != 0 && ec == 0) {
		tag = key->attr_id;
		if (tag < min_tag || tag > max_tag) {
			ec = ISNS_RSP_MSG_FORMAT_ERROR;
		} else if (key->attr_len > 0 && attrs != NULL) {
			attr = &attrs[tag - min_tag]; /* ATTR_INDEX_xxx */
			ec = extract_attr(attr, key, 0);
			if (ec == ISNS_RSP_INVALID_REGIS) {
				ec = ISNS_RSP_MSG_FORMAT_ERROR;
			}
		}
		NEXT_TLV(key, key_len);
	}

	return (ec);
}

static lookup_method_t
get_op_method(
	uint32_t tag
)
{
	lookup_method_t method = 0;

	switch (tag) {
	/* OP_STRING */
	case ISNS_EID_ATTR_ID:
	case ISNS_PORTAL_NAME_ATTR_ID:
	case ISNS_ISCSI_ALIAS_ATTR_ID:
	case ISNS_DD_SET_NAME_ATTR_ID:
	case ISNS_DD_NAME_ATTR_ID:
	case ISNS_ISCSI_NAME_ATTR_ID:
	case ISNS_PG_ISCSI_NAME_ATTR_ID:
	case ISNS_ISCSI_AUTH_METHOD_ATTR_ID:
		method = OP_STRING;
		break;
	/* OP_MEMORY_IP6 */
	case ISNS_MGMT_IP_ADDR_ATTR_ID:
	case ISNS_PORTAL_IP_ADDR_ATTR_ID:
	case ISNS_PG_PORTAL_IP_ADDR_ATTR_ID:
		method = OP_MEMORY_IP6;
		break;
	/* OP_INTEGER */
	case ISNS_ENTITY_PROTOCOL_ATTR_ID:
	case ISNS_VERSION_RANGE_ATTR_ID:
	case ISNS_ENTITY_REG_PERIOD_ATTR_ID:
	case ISNS_ENTITY_INDEX_ATTR_ID:
	case ISNS_PORTAL_PORT_ATTR_ID:
	case ISNS_ESI_INTERVAL_ATTR_ID:
	case ISNS_ESI_PORT_ATTR_ID:
	case ISNS_PORTAL_INDEX_ATTR_ID:
	case ISNS_SCN_PORT_ATTR_ID:
	case ISNS_ISCSI_NODE_TYPE_ATTR_ID:
	case ISNS_ISCSI_SCN_BITMAP_ATTR_ID:
	case ISNS_ISCSI_NODE_INDEX_ATTR_ID:
	case ISNS_PG_PORTAL_PORT_ATTR_ID:
	case ISNS_PG_TAG_ATTR_ID:
	case ISNS_PG_INDEX_ATTR_ID:
	case ISNS_DD_SET_ID_ATTR_ID:
	case ISNS_DD_SET_STATUS_ATTR_ID:
	case ISNS_DD_ID_ATTR_ID:
	/* all other attrs */
	default:
		method = OP_INTEGER;
		break;
	}

	return (method);
}

static int
cb_attrs_match(
	void *p1,
	void *p2
)
{
	isns_obj_t *obj = (isns_obj_t *)p1;
	isns_attr_t *attrs = (isns_attr_t *)
	    ((lookup_ctrl_t *)p2)->data[1].ptr;

	lookup_ctrl_t lc;
	int match = 1; /* 0: not match, otherwise: match */

	int i;

	lc.op[1] = 0;

	for (i = 0; match != 0 && i < NUM_OF_ATTRS[obj->type]; i++) {
		if (attrs->tag != 0 && attrs->len > 0) {
			lc.id[0] = i;
			lc.op[0] = get_op_method(attrs->tag);
			lc.data[0].ptr = attrs->value.ptr;
			match = key_cmp(&lc, obj) == 0 ? 1 : 0;
		}
		attrs ++;
	}

	return (match);
}

static int
attrs_match(
	isns_type_t type,
	uint32_t uid,
	isns_attr_t *attrs
)
{
	int match; /* 0: not match, otherwise: match */
	lookup_ctrl_t lc;

	SET_UID_LCP(&lc, type, uid);

	lc.data[1].ptr = (uchar_t *)attrs;

	match = cache_lookup(&lc, NULL, cb_attrs_match);

	return (match);
}

static int
insert_uid(
	uint32_t **pp,
	uint32_t *np,
	uint32_t *sp,
	uint32_t uid
)
{
	int ec = 0;

	uint32_t *p = *pp;
	uint32_t n = *np;
	uint32_t s = *sp;

	uint32_t u;
	uint32_t *t;

	/* check for duplication */
	if (n > 0 && uid <= p[n - 1]) {
		while (n-- > 0) {
			if (p[n] == uid) {
				return (0);
			}
		}
		n = *np;
		u = p[n - 1];
		p[n - 1] = uid;
		uid = u;
	}


	if (s == n) {
		s = (s == 0) ? 8 : s * 2;
		t = (uint32_t *)realloc(p, s * sizeof (uint32_t));
		if (t != NULL) {
			p = t;
			*pp = p;
			*sp = s;
		} else {
			ec = ISNS_RSP_INTERNAL_ERROR;
		}
	}

	if (ec == 0) {
		p[n ++] = uid;
		*np = n;
	}

	return (ec);
}

static int
qry_and_match(
	uint32_t **obj_uids,
	uint32_t *num_of_objs,
	uint32_t *size,
	isns_type_t type,
	uint32_t src_uid,
	isns_type_t src_type,
	isns_attr_t *attrs
)
{
	int ec = 0;

	lookup_ctrl_t lc = { 0 }; /* !!! need to be empty */
	uint32_t uid;

	const adjvex_t *vex;

	/* circular list */
	uint32_t *p[2], n[2], s[2];
	int i, j;

	uint32_t *p1, n1;
	uint32_t *p2, n2, s2;
	isns_type_t t;

	/* initialize the circular list */
	i = 0;
	j = 1;

	p[i] = *obj_uids;
	n[i] = *num_of_objs;
	s[i] = *size;

	p[j] = malloc(8 * sizeof (uint32_t));
	p[j][0] = src_uid;
	n[j] = 1;
	s[j] = 8;

	/* initial object type of being queried */
	t = src_type;

	vex = qry_puzzle[src_type][type];

	do {
		/* shift one on the circular list */
		i = (i + 1) & 1;
		j = (j + 1) & 1;

		p1 = p[i]; n1 = n[i];
		p2 = p[j]; n2 = n[j]; s2 = s[j];

		/* prepare lookup control */
		lc.type = t;
		lc.id[0] = UID_ATTR_INDEX[t];
		lc.op[0] = OP_INTEGER;

		/* result object type */
		t = vex->t;

		FOR_EACH_OBJS(p1, n1, uid, {
			/* start query */
			lc.data[0].ui = uid;
			ec = vex->f(&lc);
			uid = lc.curr_uid;
			while (ec == 0 && uid != 0) {
				if (attrs == NULL ||
				    attrs_match(type, uid, attrs) != 0) {
					ec = insert_uid(&p2, &n2, &s2, uid);
				}
				if (ec == 0) {
					ec = vex->f(&lc);
					uid = lc.curr_uid;
				} else {
					n1 = n2 = 0; /* force break */
				}
			}
		});
		if (ec == 0) {
			vex = vex->v;
		} else {
			vex = NULL; /* force break */
		}
		/* push back */
		p[j] = p2; n[j] = n2; s[j] = s2;
		/* reset the number of objects */
		n[i] = 0;
	} while (vex != NULL);

	/* clean up the memory */
	free(p1);
	if (ec != 0) {
		free(p2);
		p2 = NULL;
		n2 = 0;
		s2 = 0;
	}

	*obj_uids = p2;
	*num_of_objs = n2;
	*size = s2;

	return (ec);
}

int
get_qry_keys(
	bmp_t *nodes_bmp,
	uint32_t num_of_nodes,
	isns_type_t *type,
	isns_tlv_t *key,
	uint16_t key_len,
	uint32_t **obj_uids,
	uint32_t *num_of_objs
)
{
	int ec = 0;
	union {
		isns_obj_t o;
		isns_entity_t e;
		isns_iscsi_t i;
		isns_portal_t p;
		isns_pg_t g;
		isns_dd_t d;
		isns_dds_t s;
	} an_obj = { 0 };
	isns_attr_t *attrs;

	htab_t *htab;
	uint32_t node_uid;

	uint32_t size;

	*obj_uids = NULL;
	*num_of_objs = 0;
	size = 0;

	/* get the object type identified by the key */
	*type = TLV2TYPE(key);
	if (*type == 0) {
		return (ISNS_RSP_INVALID_QRY);
	}

	attrs = &an_obj.o.attrs[0];
	/* validate the Message Key */
	ec = validate_qry_key(*type, key, key_len, attrs);
	if (ec != 0) {
		return (ec);
	}

	if (nodes_bmp != NULL) {
		FOR_EACH_MEMBER(nodes_bmp, num_of_nodes, node_uid, {
			ec = qry_and_match(
			    obj_uids, num_of_objs, &size, *type,
			    node_uid, OBJ_ISCSI, attrs);
			if (ec != 0) {
				return (ec);
			}
		});
	} else {
		node_uid = 0;
		htab = cache_get_htab(OBJ_ISCSI);
		FOR_EACH_ITEM(htab, node_uid, {
			ec = qry_and_match(
			    obj_uids, num_of_objs, &size, *type,
			    node_uid, OBJ_ISCSI, attrs);
			if (ec != 0) {
				return (ec);
			}
		});
	}

	return (ec);
}

int
get_qry_ops(
	uint32_t uid,
	isns_type_t src_type,
	isns_type_t op_type,
	uint32_t **op_uids,
	uint32_t *num_of_ops,
	uint32_t *size
)
{
	int ec = 0;

	*num_of_ops = 0;

	ec = qry_and_match(
	    op_uids, num_of_ops, size, op_type,
	    uid, src_type, NULL);

	return (ec);
}

int
get_qry_ops2(
	uint32_t *nodes_bmp,
	uint32_t num_of_nodes,
	isns_type_t op_type,
	uint32_t **op_uids,
	uint32_t *num_of_ops,
	uint32_t *size
)
{
	int ec = 0;

	uint32_t node_uid;

	htab_t *htab;

	*num_of_ops = 0;

	if (nodes_bmp != NULL) {
		FOR_EACH_MEMBER(nodes_bmp, num_of_nodes, node_uid, {
			ec = qry_and_match(
			    op_uids, num_of_ops, size, op_type,
			    node_uid, OBJ_ISCSI, NULL);
			if (ec != 0) {
				return (ec);
			}
		});
	} else {
		node_uid = 0;
		htab = cache_get_htab(OBJ_ISCSI);
		FOR_EACH_ITEM(htab, node_uid, {
			ec = qry_and_match(
			    op_uids, num_of_ops, size, op_type,
			    node_uid, OBJ_ISCSI, NULL);
			if (ec != 0) {
				return (ec);
			}
		});
	}

	return (ec);
}

uint32_t
get_next_obj(
	isns_tlv_t *tlv,
	uint32_t tlv_len,
	isns_type_t type,
	uint32_t *uids,
	uint32_t num
)
{
	lookup_ctrl_t lc;

	uint32_t tag;
	uint8_t *value;

	uint32_t old = 0;
	uint32_t min = 0;
	uint32_t uid, diff;
	uint32_t pre_diff = 0xFFFFFFFF;

	lc.curr_uid = 0;
	lc.type = type;
	lc.op[1] = 0;
	lc.op[2] = 0;

	if (tlv_len > 8) {
		tag = tlv->attr_id;
		value = tlv->attr_value;
		switch (tag) {
		case ISNS_EID_ATTR_ID:
			lc.id[0] = ATTR_INDEX_ENTITY(ISNS_EID_ATTR_ID);
			lc.op[0] = OP_STRING;
			lc.data[0].ptr = (uchar_t *)value;
			break;
		case ISNS_ISCSI_NAME_ATTR_ID:
			lc.id[0] = ATTR_INDEX_ISCSI(ISNS_ISCSI_NAME_ATTR_ID);
			lc.op[0] = OP_STRING;
			lc.data[0].ptr = (uchar_t *)value;
			break;
		case ISNS_ISCSI_NODE_INDEX_ATTR_ID:
			lc.id[0] = ATTR_INDEX_ISCSI(
			    ISNS_ISCSI_NODE_INDEX_ATTR_ID);
			lc.op[0] = OP_INTEGER;
			lc.data[0].ui = ntohl(*(uint32_t *)value);
			break;
		case ISNS_PORTAL_IP_ADDR_ATTR_ID:
			lc.id[0] = ATTR_INDEX_PORTAL(
			    ISNS_PORTAL_IP_ADDR_ATTR_ID);
			lc.op[0] = OP_MEMORY_IP6;
			lc.data[0].ip = (in6_addr_t *)value;
			NEXT_TLV(tlv, tlv_len);
			if (tlv_len > 8 &&
			    ((tag = tlv->attr_id) ==
			    ISNS_PORTAL_PORT_ATTR_ID)) {
				value = tlv->attr_value;
				lc.id[1] = ATTR_INDEX_PORTAL(
				    ISNS_PORTAL_PORT_ATTR_ID);
				lc.op[1] = OP_INTEGER;
				lc.data[1].ui = ntohl(*(uint32_t *)value);
			} else {
				return (0);
			}
			break;
		case ISNS_PORTAL_INDEX_ATTR_ID:
			lc.id[0] = ATTR_INDEX_PORTAL(ISNS_PORTAL_INDEX_ATTR_ID);
			lc.op[0] = OP_INTEGER;
			lc.data[0].ui = ntohl(*(uint32_t *)value);
			break;
		case ISNS_PG_INDEX_ATTR_ID:
			lc.id[0] = ATTR_INDEX_PG(ISNS_PG_INDEX_ATTR_ID);
			lc.op[0] = OP_INTEGER;
			lc.data[0].ui = ntohl(*(uint32_t *)value);
			break;
		default:
			return (0);
		}

		old = is_obj_there(&lc);
		if (old == 0) {
			return (0);
		}
	}

	while (num > 0) {
		uid = uids[-- num];
		if (uid > old) {
			diff = uid - old;
			if (diff < pre_diff) {
				min = uid;
				pre_diff = diff;
			}
		}
	}

	return (min);
}

static int
cb_qry_rsp(
	void *p1,
	void *p2
)
{
	int ec = 0;

	isns_obj_t *obj = (isns_obj_t *)p1;
	lookup_ctrl_t *lcp = (lookup_ctrl_t *)p2;

	uint16_t tlv_len = lcp->id[1];
	isns_tlv_t *tlv = (isns_tlv_t *)lcp->data[1].ptr;
	conn_arg_t *conn = (conn_arg_t *)lcp->data[2].ptr;

	isns_type_t type = obj->type;
	uint32_t min_tag = TAG_RANGE[type][0];
	uint32_t mid_tag = TAG_RANGE[type][1];
	uint32_t max_tag = TAG_RANGE[type][2];

	isns_attr_t *attr;
	uint32_t tag;
	uint32_t id;
	uint32_t len;
	void *value;

	isns_pdu_t *rsp = conn->out_packet.pdu;
	size_t pl = conn->out_packet.pl;
	size_t sz = conn->out_packet.sz;

	do {
		if (tlv->attr_len == 0) {
			tag = tlv->attr_id;
			if (tag <= mid_tag) {
				id = ATTR_INDEX(tag, type);
				attr = &obj->attrs[id];
				len = attr->len;
				value = (void *)attr->value.ptr;
				ec = pdu_add_tlv(&rsp, &pl, &sz,
				    tag, len, value, 0);
			}
		}
		NEXT_TLV(tlv, tlv_len);
	} while (ec == 0 &&
	    tlv_len >= 8 &&
	    tlv->attr_id >= min_tag &&
	    tlv->attr_id <= max_tag);

	conn->out_packet.pdu = rsp;
	conn->out_packet.pl = pl;
	conn->out_packet.sz = sz;

	return (ec);
}

int
get_qry_attrs(
	uint32_t uid,
	isns_type_t type,
	isns_tlv_t *tlv,
	uint16_t tlv_len,
	conn_arg_t *conn
)
{
	int ec = 0;

	lookup_ctrl_t lc;

	SET_UID_LCP(&lc, type, uid);

	lc.id[1] = tlv_len;
	lc.data[1].ptr = (uchar_t *)tlv;
	lc.data[2].ptr = (uchar_t *)conn;

	ec = cache_lookup(&lc, NULL, cb_qry_rsp);

	return (ec);
}

int
get_qry_attrs1(
	uint32_t uid,
	isns_type_t type,
	isns_tlv_t *tlv,
	uint16_t tlv_len,
	conn_arg_t *conn
)
{
	isns_tlv_t *tmp = tlv;
	uint32_t tmp_len = tlv_len;

	/* clear the length of all of tlv */
	while (tmp_len > 8) {
		tmp->attr_len = 0;
		NEXT_TLV(tmp, tmp_len);
	}

	return (get_qry_attrs(uid, type, tlv, tlv_len, conn));
}