/*
 * 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
 */
/*
 *	db_mindex.cc
 *
 *  Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 *  Use is subject to license terms.
 */

#include <stdio.h>

#include <malloc.h>
#include <strings.h>
#include <string.h>
#include <sys/param.h>
#include "db_headers.h"
#include "db.h"
#include "db_mindex.h"
#include "db_pickle.h"
#include "nisdb_mt.h"
#include "nisdb_ldap.h"
#include "ldap_nisdbquery.h"
#include "ldap_map.h"
#include "ldap_ruleval.h"
#include "ldap_scheme.h"
#include "ldap_parse.h"
#include "nis_hashitem.h"

/*
 *  Constructor:  Create new table using scheme defintion supplied.
 *  (Make copy of scheme and keep it with table.)
 */
db_mindex::db_mindex(db_scheme *how, char *tablePath) : rversion()
{
	noWriteThrough.flag = 0;
	noLDAPquery.flag = 0;
	initialLoad.flag = 0;
	objPath.ptr = NULL;
	init(how);
	if (tablePath != NULL)
		configure(tablePath);
}

/* Constructor:  Create empty table (no scheme, no table or indices). */
db_mindex::db_mindex() : rversion()
{
	scheme = NULL;
	table = NULL;
	indices.indices_len = 0;
	indices.indices_val = NULL;
	noWriteThrough.flag = 0;
	noLDAPquery.flag = 0;
	initialLoad.flag = 0;
	objPath.ptr = NULL;
	INITRW(mindex);
}

db_mindex::~db_mindex()
{
	reset();   /* get rid of data structures first */
	DESTROYRW(mindex);
}

/*
 * Initialize table using information given in scheme 'how'.
 * Record the scheme for later use (make copy of it);
 * create the required number of indices; and create table for storing
 * entries.
 */
void
db_mindex::init(db_scheme * how)
{
	scheme = new db_scheme(how);		// make copy
	if (scheme == NULL)
		FATAL("db_mindex::init: could not allocate space for scheme",
			DB_MEMORY_LIMIT);

	if (scheme->numkeys() == 0) {
	    WARNING("db_mindex::init: empty scheme encountered");
	    /* what action should we take here? */
	}

	indices.indices_len = how->numkeys();
	db_key_desc * keys = how->keyloc();
	int i;

	/* homogeneous indices for now */
	indices.indices_val = new db_index[indices.indices_len];
	if (indices.indices_val == NULL) {
		delete scheme;
		indices.indices_len = 0;
		scheme = NULL;
		FATAL("db_mindex::init: could not allocate space for indices",
			DB_MEMORY_LIMIT);
	}
	for (i = 0; i < indices.indices_len; i++) {
		indices.indices_val[i].init(&(keys[i]));
	}
	table = new db_table();
	if (table == NULL) {
		delete scheme;
		scheme = NULL;
		delete indices.indices_val;
		indices.indices_val = NULL;
		indices.indices_len = 0;
		FATAL("db_mindex::init: could not allocate space for table",
			DB_MEMORY_LIMIT);
	}
	rversion.zero();
	INITRW(mindex);
	objPath.ptr = NULL;
}

/* empty associated tables associated */
void
db_mindex::reset_tables()
{
	int i;

	WRITELOCKV(this, "w db_mindex::reset_tables");
	/* Add sanity check in case of table corruption */
	if (indices.indices_val != NULL) {
		for (i = 0; i < indices.indices_len; i++) {
			indices.indices_val[i].reset();
		}
	}
	if (table) table->reset();
	WRITEUNLOCKV(this, "wu db_mindex::reset_tables");
}


/*
 * Return a list of index_entries that satsify the given query 'q'.
 * Return the size of the list in 'count'. Return NULL if list is empty.
 * Return in 'valid' FALSE if query is not well formed.
*/
db_index_entry_p
db_mindex::satisfy_query(db_query *q, long *count, bool_t *valid) {
	return (satisfy_query(q, count, valid, FALSE));
}

db_index_entry_p
db_mindex::satisfy_query(db_query *q, long *count, bool_t *valid,
			bool_t fromLDAP) {
	db_index_entry_p	ret;
	bool_t			validRequest;
	int			queryRes;

	/* Make sure we have somewhere to store the "request valid" status */
	if (valid == NULL)
		valid = &validRequest;

	/* Prepare for a failed lock */
	*count = 0;
	*valid = FALSE;

	READLOCK(this, NULL, "r db_mindex::satisfy_query");

	/*
	 * Only get data from LDAP if the caller requested it,
	 * and if we're mapping for this table.
	 */
	fromLDAP = (fromLDAP && !noLDAPquery.flag &&
		(table->mapping.fromLDAP ||
			table->mapping.objType != NIS_TABLE_OBJ));

	/*
	 * If we always fetch data from LDAP for query's, then do so now,
	 * before invoking the "real" satisfy_query().
	 */
	if (fromLDAP && table->mapping.matchFetch == mat_always) {
		int	lockcode = 0;

		READLOCKNR(table, lockcode,
				"r db_mindex::satisfy_query table");
		if (lockcode != 0) {
			READUNLOCK(this, NULL, "ru db_mindex::satisfy_query");
			return (NULL);
		}

		queryRes = queryLDAP(q, 0, 1);

		READUNLOCKNR(table, lockcode,
				"ru db_mindex::satisfy_query table");
		if (lockcode != 0) {
			READUNLOCK(this, NULL, "ru db_mindex::satisfy_query");
			return (NULL);
		}
		if (queryRes != LDAP_SUCCESS) {
			/* queryLDAP() sets error codes etc. */
			READUNLOCK(this, NULL, "ru db_mindex::satisfy_query");
			return (NULL);
		}

	}

	ret = satisfy_query_dbonly(q, count, fromLDAP ? TRUE : FALSE, valid);

	/* If we found it, or if we're not mapping, return */
	if (ret != NULL || !fromLDAP) {
		READUNLOCK(this, NULL, "ru db_mindex::satisfy_query");
		return (ret);
	} else if (ret == NULL && !(*valid)) {
		/* No result, and the request wasn't valid */
		READUNLOCK(this, NULL, "ru db_mindex::satisfy_query");
		return (NULL);
	}

	/* Get data from LDAP */
	if (table->mapping.matchFetch != mat_never) {
		queryRes = queryLDAP(q, 0, 1);
	} else {
		/*
		 * We'll now go on to check for an un-expired entry again,
		 * even though we're pretty sure that won't work (already
		 * did that, and nothing's changed). However, we accept that
		 * slight inefficiency in the interest of keeping the code
		 * simple; we expect 'mat_never' to be used very rarely.
		 */
		queryRes = LDAP_SUCCESS;
	}

	if (queryRes == LDAP_SUCCESS) {
		/*
		 * Check if we've got a match now. If not, try one
		 * last time for an expired match.
		 */
		ret = satisfy_query_dbonly(q, count, TRUE, valid);
		if (ret == NULL) {
			ret = satisfy_query_dbonly(q, count, FALSE, valid);
		}
	} else {
		/*
		 * Check if we have an expired entry; if so, return
		 * it with an appropriate status.
		 */
		ret = satisfy_query_dbonly(q, count, FALSE, valid);
	}

	READUNLOCK(this, NULL, "ru db_mindex::satisfy_query");

	return (ret);
}

db_index_entry_p
db_mindex::satisfy_query_dbonly(db_query *q, long *count,
				bool_t checkExpire, bool_t *valid)
{
	db_index_entry_p oldres = NULL, newres;
	int i, curr_ind;
	long num_new, num_old = 0;
	int limit = q->size();
	db_qcomp * comps = q->queryloc();

	if (valid) *valid = TRUE;   /* True to begin with. */

	/* Add sanity check in case table corrupted */
	if (indices.indices_len != 0 && indices.indices_val == NULL) {
		WARNING("db_mindex::satisfy_query: table has no indices");
		if (valid) *valid = FALSE;
		*count = 0;
		return (NULL);
	}

	for (i = 0; i < limit; i++) {
		if ((curr_ind = comps[i].which_index) < indices.indices_len) {
			newres = indices.indices_val[curr_ind].lookup(
					comps[i].index_value, &num_new,
					table, checkExpire);
			if (newres == NULL) {
				*count = 0;
				return (NULL);
			}
			if (oldres == NULL) {
				oldres = newres;
				num_old = num_new;
			} else {
				oldres = newres->join(num_new, num_old,
							oldres, &num_old);
				if (oldres == NULL) {
					*count = 0;
					return (NULL);
				}
			}
		} else {
			WARNING("db_mindex::satisfy_query: index out of range");
			if (valid) *valid = FALSE;
			*count = 0;
			return (NULL);
		}
	}
	*count = num_old;
	return (oldres);
}

/*
 * Returns an array of size 'count' of 'entry_object_p's, pointing to
 * copies of entry_objects named by the result list of db_index_entries 'res'.
 * Sets db_status 'statp' if error encountered; otherwise, leaves it unchanged.
*/
entry_object_p *
db_mindex::prepare_results(int count, db_index_entry_p res, db_status *statp)
{
	READLOCK(this, NULL, "r db_mindex::prepare_results");
	READLOCK2(table, NULL, "r table db_mindex::prepare_results", this);
	entry_object_p * entries = new entry_object_p[count];
	int i;

	if (entries == NULL) {
		READUNLOCK2(this, table, NULL, NULL,
	"ru db_mindex::prepare_results: could not allocate space",
	"ru table db_mindex::prepare_results: could not allocate space");
		FATAL3("db_mindex::prepare_results: could not allocate space",
			DB_MEMORY_LIMIT, NULL);
	}

	for (i = 0; i < count; i++) {
		if (res == NULL) {
			int j;
			for (j = 0; j < i; j++) // cleanup
				free_entry(entries[j]);
			syslog(LOG_ERR,
				"db_mindex::prepare_results: incorrect count");
			*statp = DB_INTERNAL_ERROR;
		} else {
			entries[i] =
				new_entry(table->get_entry(res->getlocation()));
			res = res->getnextresult();
		}
	}
	READUNLOCK2(this, table, entries, entries,
			"ru db_mindex::prepare_results",
			"ru db_mindex::prepare_results");

	return (entries);
}

/*
 * Returns a newly created db_query structure containing the index values
 * as obtained from the record named by 'recnum'.  The record itself, along
 * with information on the schema definition of this table, will determine
 * which values are extracted from the record and placed into the result.
 * Returns NULL if recnum is not a valid entry.
 * Note that space is allocated for the query and the index values
 * (i.e. do not share pointers with strings in 'obj'.)
 */
db_query *
db_mindex::extract_index_values_from_record(entryp recnum)
{
	db_query	*ret;

	ret = extract_index_values_from_object(table->get_entry(recnum));
	return (ret);
}

/*
 * Returns a newly created db_query containing the index values as
 * obtained from the given object.  The object itself,
 * along with information on the scheme given, will determine
 * which values are extracted from the object and placed into the query.
 * Returns an empty query if 'obj' is not a valid entry.
 * Note that space is allocated for the query and the index values
 * (i.e. do not share pointers with strings in 'obj'.)
*/
db_query *
db_mindex::extract_index_values_from_object(entry_object_p obj)
{
	READLOCK(this, NULL, "r db_mindex::extract_index_values_from_object");
	if (scheme->numkeys() != indices.indices_len) { // probably built wrong
		syslog(LOG_ERR,
	    "number of keys (%d) does not equal number of indices (%d)",
	    scheme->numkeys(), indices.indices_len);
		READUNLOCK(this, NULL,
			"ru db_mindex::extract_index_values_from_object");
		return (new db_query());	// null query
	} else if (obj == NULL) {
		READUNLOCK(this, NULL,
			"ru db_mindex::extract_index_values_from_object");
		return (NULL);
	} else {
		db_query* answer = new db_query(scheme, obj);
		if (answer) {
			/*
			 * XXX If the unlock fails, and we return NULL,
			 * we leak 'answer'. On the other hand, if we
			 * return 'answer', the object may remain locked,
			 * but the caller doesn't know that anything
			 * went wrong.
			 */
			READUNLOCK(this, NULL,
			"ru db_mindex::extract_index_values_from_object");
			return (answer);
		} else {
			FATAL3("db_mindex::extract: could not allocate space",
				DB_MEMORY_LIMIT, NULL);
		}
	}
	READUNLOCK(this, NULL,
		"ru db_mindex::extract_index_values_from_object");
	return (NULL);
}

/*
 * Returns the first entry found in the table by setting 'answer' to
 * point to the a copy of entry_object.  Returns DB_SUCCESS if found;
 * DB_NOTFOUND otherwise.
*/
db_status
db_mindex::first(entryp *where, entry_object ** answer)
{
	db_status	ret = DB_SUCCESS;

	/*
	 * table->first_entry() returns a pointer into the table, so
	 * we must keep the table read locked until we've copied the
	 * entry_object. In order to maintain lock integrity, we must
	 * lock the db_mindex (this) before the db_table (table).
	 */
	READLOCK(this, DB_LOCK_ERROR, "r db_mindex::first");
	READLOCK2(table, DB_LOCK_ERROR, "r table db_mindex::first", this);
	if (table->mapping.fromLDAP) {
		struct timeval	now;
		(void) gettimeofday(&now, NULL);
		if (now.tv_sec >= table->mapping.enumExpire) {
			int queryRes = queryLDAP(0, 0, 1);
			if (queryRes == LDAP_SUCCESS)
				table->mapping.enumExpire = now.tv_sec +
					table->mapping.ttl;
			else {
				READUNLOCK2(this, table,
					DB_LOCK_ERROR, DB_LOCK_ERROR,
					"ru db_mindex::first LDAP",
					"ru table db_mindex::first LDAP");
				return (DB_INTERNAL_ERROR);
			}
		}
	}
	entry_object_p ptr = table->first_entry(where);
	if (ptr == NULL)
		ret = DB_NOTFOUND;
	else
		*answer = new_entry(ptr);
	READUNLOCK2(this, table, ret, ret,
		"ru db_mindex::first", "ru table db_mindex::first");
	return (ret);
}

/*
 * Returns the next entry in the table after 'previous' by setting 'answer' to
 * point to copy of the entry_object.  Returns DB_SUCCESS if 'previous' is
 * valid and next entry is found; DB_NOTFOUND otherwise.  Sets 'where' to
 * location of where entry is found for input as subsequent 'next' operation.
*/
db_status
db_mindex::next(entryp previous, entryp *where, entry_object **answer)
{
	db_status	ret = DB_SUCCESS;

	READLOCK(this, DB_LOCK_ERROR, "r db_mindex::next");
	READLOCK2(table, DB_LOCK_ERROR, "r db_mindex::next", this);
	if (!(table->entry_exists_p(previous)))
		ret = DB_NOTFOUND;
	else {
		entry_object * ptr = table->next_entry(previous, where);
		if (ptr == NULL)
			ret = DB_NOTFOUND;
		else
			*answer = new_entry(ptr);
	}
	READUNLOCK2(this, table, ret, ret,
		"ru db_mindex::next", "ru table db_mindex::next");
	return (ret);
}

static void
delete_result_list(db_next_index_desc* orig)
{
	db_next_index_desc* curr, *save_next;
	for (curr = orig; curr != NULL; 0) {
		save_next = curr->next;
		delete curr;
		curr = save_next;
	}
}


static db_next_index_desc *
copy_result_list(db_index_entry* orig)
{
	db_next_index_desc *head = NULL, *curr;
	db_index_entry *current;

	for (current = orig; current != NULL;
		current = current->getnextresult()) {
		curr = new db_next_index_desc(current->getlocation(), head);
		if (curr == NULL) {
			FATAL3(
			"db_mindex::copy_result_list: could not allocate space",
			DB_MEMORY_LIMIT, NULL);
		}
		head = curr;  // list is actually reversed
	}
	return (head);
}

/*
 * Delete the given list of results; used when no longer interested in
 * the results of the first/next query that returned this list.
 */
db_status
db_mindex::reset_next(db_next_index_desc *orig)
{
	if (orig == NULL)
		return (DB_NOTFOUND);

	delete_result_list(orig);
	return (DB_SUCCESS);
}

/*
* Finds entry that satisfy the query 'q'.  Returns the first answer by
* setting the pointer 'answer' to point to a copy of it.  'where' is set
* so that the other answers could be gotten by passing 'where' to 'next'
* successively.   Note that the answer is a  pointer to a copy of the entry.
* Returns DB_SUCCESS if search was successful; DB_NOTFOUND otherwise.
 */
db_status
db_mindex::first(db_query *q,
		db_next_index_desc **where, entry_object ** answer)
{
	READLOCK(this, DB_LOCK_ERROR, "r db_mindex::first");
	READLOCK2(table, DB_LOCK_ERROR, "r table db_mindex::first", this);
	long count;
	bool_t valid_query;
	db_status	ret = DB_SUCCESS;
	db_index_entry * rp = satisfy_query(q, &count, &valid_query, TRUE);

	if (valid_query != TRUE)
		ret =  DB_BADQUERY;
	else if (rp == NULL) {
		*answer = NULL;
		ret = DB_NOTFOUND;
	} else {
		*where = copy_result_list(rp);

		entry_object_p ptr = table->get_entry((*where)->location);
		if (ptr == NULL)
			ret = DB_NOTFOUND;
		else
			*answer = new_entry(ptr);
	}
	READUNLOCK2(this, table, ret, ret,
		"ru db_mindex::first", "ru table db_mindex::first");
	return (ret);
}

/*
 * Returns the next entry in the table after 'previous' by setting 'answer' to
 * point to copy of the entry_object.  Next is next in chain of answers found
 * in previous first search with query.   Returns DB_SUCCESS if 'previous' is
 * valid and next entry is found; DB_NOTFOUND otherwise.  Sets 'where' to
 * location of where entry is found for input as subsequent 'next' operation.
*/
db_status
db_mindex::next(db_next_index_desc *previous, db_next_index_desc **where,
		entry_object **answer)
{
	READLOCK(this, DB_LOCK_ERROR, "r db_mindex::next");
	READLOCK2(table, DB_LOCK_ERROR, "r table db_mindex::next", this);
	db_status	ret = DB_SUCCESS;

	if (previous == NULL)
		ret = DB_NOTFOUND;
	else {
		// should further check validity of 'previous' pointer
		*where = previous->next;
		delete previous;    // delete previous entry
		if (*where == NULL)
			ret = DB_NOTFOUND;
		else {
			entry_object * ptr =
				table->get_entry((*where)->location);
			if (ptr == NULL)
				ret = DB_NOTFOUND;
			else {
				*answer = new_entry(ptr);
				ret = DB_SUCCESS;
			}
		}
	}
	READUNLOCK2(this, table, ret, ret,
		"ru db_mindex::next", "ru table db_mindex::next");
	return (ret);
}

/*
 * Finds entry that satisfy the query 'q'.  Returns the answer by
 * setting the pointer 'rp' to point to the list of answers.
 * Note that the answers are pointers to the COPIES of entries.
 * Returns the number of answers find in 'count'.
 * Returns DB_SUCCESS if search found at least one answer;
 * returns DB_NOTFOUND if none is found.
*/
db_status
db_mindex::lookup(db_query *q, long *count, entry_object_p **result)
{
	bool_t valid_query;
	db_index_entry * rp = satisfy_query(q, count, &valid_query, TRUE);
	db_status stat = DB_SUCCESS;

	if (valid_query != TRUE)
		return (DB_BADQUERY);

	if (rp == NULL) {
		*result = NULL;
		return (DB_NOTFOUND);
	}

	*result = prepare_results((int)*count, rp, &stat);

	return (stat);
}

/*
 * Return all entries within table.  Returns the answer by
 * setting the pointer 'rp' to point to the list of answers.
 * Note that the answers are pointers to copies of the entries.
 * Returns the number of answers find in 'count'.
 * Returns DB_SUCCESS if search found at least one answer;
 * returns DB_NOTFOUND if none is found.
*/
db_status
db_mindex::all(long *count, entry_object_p **result)
{
	entry_object *ptr;
	entryp where;
	long how_many, i;
	int	lret = 0;

	if (table == NULL) {
		*result = NULL;
		return (DB_NOTFOUND);
	}

	READLOCK(this, DB_LOCK_ERROR, "r db_mindex::all");
	/* Read lock 'table' while we're traversing it */
	READLOCKNR(table, lret, "r table db_mindex::all");
	if (lret != 0) {
		READUNLOCK(this, DB_LOCK_ERROR, "ru db_mindex::all");
		return (DB_LOCK_ERROR);
	}

	if (table->mapping.fromLDAP) {
		struct timeval	now;
		(void) gettimeofday(&now, NULL);
		if (now.tv_sec >= table->mapping.enumExpire) {
			int	queryRes = queryLDAP(0, 0, 1);
			if (queryRes != LDAP_SUCCESS) {
				READUNLOCKNR(table, lret,
					"ru table db_mindex::all LDAP");
				READUNLOCK(this, DB_LOCK_ERROR,
					"ru db_mindex::all LDAP");
				return (DB_INTERNAL_ERROR);
			}
		}
	}

	if ((how_many = table->fullness()) <= 0) {
		/*
		 * Set '*count' so that the caller avoids putting garbage
		 * in an 'objects_len' field.
		 */
		*count = 0;
		*result = NULL;
		READUNLOCKNR(table, lret, "ru table db_mindex::all");
		READUNLOCK(this, DB_NOTFOUND, "ru db_mindex::all");
		return (DB_NOTFOUND);
	}

	entry_object_p * answer = new entry_object_p[how_many];
	if (answer == NULL) {
		READUNLOCKNR(table, lret, "ru table db_mindex::all");
		READUNLOCK(this, DB_MEMORY_LIMIT, "ru db_mindex::all");
		FATAL3("db_mindex::all: could not allocate space",
			DB_MEMORY_LIMIT, DB_MEMORY_LIMIT);
	}

	*count = how_many;

	ptr = table->first_entry(&where);
	if (ptr != NULL)
		answer[0] = new_entry(ptr);
	else {
		WARNING("db_mindex::all: null first entry found in all");
		answer[0] = NULL;
	}
	for (i = 1; i < how_many; i++) {
		ptr = table->next_entry(where, &where);
		if (ptr != NULL)
			answer[i] = new_entry(ptr);
		else {
			WARNING(
			    "db_mindex::all: null internal entry found in all");
			answer[i] = NULL; /* Answer gets null too. -CM */
		}
	}

	READUNLOCKNR(table, lret, "ru table db_mindex::all");

	*result = answer;
	READUNLOCK(this, DB_SUCCESS, "ru db_mindex::all");
	return (DB_SUCCESS);
}

/*
 * Remove the entry identified by 'recloc' from:
 * 1.  all indices, as obtained by extracting the index values from the entry
 * 2.  table where entry is stored.
*/
db_status
db_mindex::remove_aux(entryp recloc)
{
	int i, curr_ind;
	db_status	res = DB_SUCCESS;

	WRITELOCK(this, DB_LOCK_ERROR, "w db_mindex::remove_aux");
	/* get index values of this record */
	db_query * cq = extract_index_values_from_record(recloc);
	if (cq == NULL) {
		WRITEUNLOCK(this, DB_MEMORY_LIMIT, "wu db_mindex::remove_aux");
		FATAL3("db_mindex::remove_aux: could not allocate space",
			DB_MEMORY_LIMIT, DB_MEMORY_LIMIT);
	}
	if (cq->size() != indices.indices_len) { /* something is wrong */
		delete cq; // clean up
		syslog(LOG_ERR,
	    "db_mindex::remove_aux: record contains wrong number of indices");
		WRITEUNLOCK(this, DB_INTERNAL_ERROR,
			"wu db_mindex::remove_aux");
		return (DB_INTERNAL_ERROR);
	}

	if (!noWriteThrough.flag) {
		nis_object	*o = 0;
		entry_object    *e = table->get_entry(recloc);
		int		queryRes, doingModify;

		/*
		 * If the removal is part of a modify operation, we
		 * defer the LDAP update until the modified NIS+ object
		 * is added back.
		 */
		if (saveOldObjForModify((entry_obj *)e, &doingModify) == 0)
			res = DB_INTERNAL_ERROR;

		if (res == DB_SUCCESS && !doingModify) {
			/*
			 * If we're removing a directory entry, and the
			 * entry is LDAP-mapped, but the directory isn't,
			 * we need a copy of the entry object in order
			 * to remove if from LDAP.
			 */
			if (e != 0 && e->en_type != 0 &&
					strcmp(e->en_type, "IN_DIRECTORY") == 0)
				o = unmakePseudoEntryObj(e, 0);
			queryRes = removeLDAP(cq, o);
			if (queryRes != LDAP_SUCCESS) {
				if (table->mapping.storeErrorDisp == abandon)
					res = DB_INTERNAL_ERROR;
			}
			if (o != 0)
				nis_destroy_object(o);
		}
	}

	if (res == DB_SUCCESS) {
		db_qcomp * comps = cq->queryloc();

		/* Add sanity check in case of corrupted table */
		if (indices.indices_val != NULL) {
			/* update indices */
			for (i = 0; i < indices.indices_len; i++) {
				/* unnec. if sorted */
				curr_ind = comps[i].which_index;
				indices.indices_val[curr_ind].remove(
						comps[i].index_value, recloc);
			}
		}

		/* update table where record is stored */
		table->delete_entry(recloc);
	}

	/* delete query */
	delete cq;

	WRITEUNLOCK(this, DB_SUCCESS, "wu db_mindex::remove_aux");

	return (res);
}

/*
 * Removes the entry in the table named by given query 'q'.
 * If a NULL query is supplied, all entries in table are removed.
 * Returns DB_NOTFOUND if no entry is found.
 * Returns DB_SUCCESS if one entry is found; this entry is removed from
 * its record storage, and it is also removed from all the indices of the
 * table. If more than one entry satisfying 'q' is found, all are removed.
 */
db_status
db_mindex::remove(db_query *q)
{
	long count = 0;
	db_index_entry *rp;
	db_status rstat;
	bool_t valid_query;

	WRITELOCK(this, DB_LOCK_ERROR, "w db_mindex::remove");
	WRITELOCK2(table, DB_LOCK_ERROR, "w table db_mindex::remove", this);
	if (q == NULL)  {  /* remove all entries in table */
		if (table->mapping.toLDAP && !noWriteThrough.flag) {
			int	queryRes = removeLDAP(q, 0);
#ifdef	NISDB_LDAP_DEBUG
			if (queryRes != LDAP_SUCCESS)
				abort();
#endif	/* NISDB_LDAP_DEBUG */
		}
		if (table != NULL && table->getsize() > 0) {
			reset_tables();
			WRITEUNLOCK2(table, this, DB_SUCCESS, DB_SUCCESS,
					"wu table db_mindex::remove",
					"wu db_mindex::remove");
			return (DB_SUCCESS);
		} else {
			WRITEUNLOCK2(table, this, DB_NOTFOUND, DB_NOTFOUND,
					"wu table db_mindex::remove",
					"wu db_mindex::remove");
			return (DB_NOTFOUND);
		}
	}

	rp = satisfy_query(q, &count, &valid_query, FALSE);

	if (valid_query != TRUE) {
		WRITEUNLOCK2(table, this, DB_BADQUERY, DB_BADQUERY,
			"wu table db_mindex::remove", "wu db_mindex::remove");
		return (DB_BADQUERY);
	}

	if (count == 0) {	/* not found */
		WRITEUNLOCK2(table, this, DB_NOTFOUND, DB_NOTFOUND,
			"wu table db_mindex::remove", "wu db_mindex::remove");
		return (DB_NOTFOUND);
	} else if (count == 1) {	/* found, update indices  */
		db_status	s;

		s = remove_aux(rp->getlocation());

		WRITEUNLOCK2(table, this, s, s,
			"wu table db_mindex::remove", "wu db_mindex::remove");
		return (s);
	} else {		/* ambiguous, remove all entries */
		int i;
		db_index_entry *next_entry;
		for (i = 0; i < count; i++) {
			if (rp == NULL) {
				syslog(LOG_ERR,
			"db_mindex::remove:  incorrect number of indices");
				WRITEUNLOCK2(table, this, DB_INTERNAL_ERROR,
					DB_INTERNAL_ERROR,
					"wu table db_mindex::remove",
					"wu db_mindex::remove");
				return (DB_INTERNAL_ERROR);
			}

			next_entry = rp->getnextresult(); // save before removal
			rstat = remove_aux(rp->getlocation());
			if (rstat != DB_SUCCESS) {
				WRITEUNLOCK2(table, this, rstat, rstat,
					"wu table db_mindex::remove",
					"wu db_mindex::remove");
				return (rstat);
			}
			rp = next_entry;		// go on to next
		}
		WRITEUNLOCK2(table, this, DB_SUCCESS, DB_SUCCESS,
			"wu table db_mindex::remove", "wu db_mindex::remove");
		return (DB_SUCCESS);
	}
}

/*
 * Add copy of given entry to table.  Entry is identified by query 'q'.
 * The entry (if any) satisfying the query is first deleted, then
 *  added to the indices (using index values extracted form the given entry)
 * and the table.
 * Returns DB_NOTUNIQUE if more than one entry satisfies the query.
 * Returns DB_NOTFOUND if query is not well-formed.
 * Returns DB_SUCCESS if entry can be added.
*/
db_status
db_mindex::add(db_query *q, entry_object * obj)
{
	long count = 0;
	int i, curr_ind;
	bool_t valid;
	db_index_entry *rp = NULL;
	db_status rstat;
	const char	*myself = "db_mindex::add";

	/*
	 *  The argument q is only NULL when we know that there are
	 *  no objects in the database that match the object.
	 */
	WRITELOCK(this, DB_LOCK_ERROR, "w db_mindex::add");
	WRITELOCK2(table, DB_LOCK_ERROR, "w table db_mindex::add", this);
	if (q) {
		rp = satisfy_query(q, &count, &valid, FALSE);
		if (!valid) {
			WRITEUNLOCK2(this, table, DB_LOCK_ERROR, DB_LOCK_ERROR,
					"wu db_mindex::add",
					"wu table db_mindex::add");
			return (DB_BADQUERY);
		}
	}
	if (count == 1) {	/* found, first delete */
		rstat = remove_aux(rp->getlocation());
		if (rstat != DB_SUCCESS) {
			WRITEUNLOCK2(this, table, rstat, rstat,
				"wu db_mindex::add",
				"wu table db_mindex::add");
			return (rstat);
		}
		count = 0;	/* fall through to add */
	}

	if (count == 0) { 	/* not found, insert */
		/* add object to table */
		entryp recloc = table->add_entry(obj, initialLoad.flag);
		/* get index values of this object, might be same as 'q' */
		db_query *cq = extract_index_values_from_object(obj);
		if (cq == NULL) {
			table->delete_entry(recloc);
			WRITEUNLOCK2(this, table,
				DB_MEMORY_LIMIT, DB_MEMORY_LIMIT,
				"wu db_mindex::add DB_MEMORY_LIMIT",
				"wu table db_mindex::add DB_MEMORY_LIMIT");
			FATAL3("db_mindex::add: could not allocate space for",
				DB_MEMORY_LIMIT, DB_MEMORY_LIMIT);
		}
		if (cq ->size() != indices.indices_len) { /* something wrong */
			table->delete_entry(recloc);
			delete cq; // clean up
			syslog(LOG_ERR,
		    "db_mindex::add: record contains wrong number of indices");
			WRITEUNLOCK2(this, table,
				DB_INTERNAL_ERROR, DB_INTERNAL_ERROR,
				"wu db_mindex::add DB_INTERNAL_ERROR",
				"wu table db_mindex::add DB_INTERNAL_ERROR");
			return (DB_INTERNAL_ERROR);
		}
		db_qcomp * comps = cq->queryloc();

		/* update indices */
		if (indices.indices_val != NULL) {
			for (i = 0; i < indices.indices_len; i++) {
				curr_ind = comps[i].which_index;
				indices.indices_val[curr_ind].add(
					comps[i].index_value, recloc);
			}
		}
		delete cq;  // clean up
		if (!noWriteThrough.flag) {
			int		queryRes;
			entry_object	*e = 0;

			if (retrieveOldObjForModify((entry_obj **)&e) == 0) {
				logmsg(MSG_NOTIMECHECK, LOG_ERR,
			"%s: Error retrieving old object for LDAP update",
					myself);
				return (DB_INTERNAL_ERROR);
			}

			queryRes = storeLDAP(q, obj, 0, e, 0);
			if (queryRes != LDAP_SUCCESS) {
				if (table->mapping.storeErrorDisp == abandon) {
					WRITEUNLOCK2(this, table,
						DB_INTERNAL_ERROR,
						DB_INTERNAL_ERROR,
						"wu db_mindex::add LDAP",
						"wu table db_mindex::add LDAP");
					return (DB_INTERNAL_ERROR);
				} else {
					logmsg(MSG_NOTIMECHECK, LOG_WARNING,
						"%s: LDAP store failed: %s",
						myself,
						ldap_err2string(queryRes));
				}
			}
		}
		rstat = DB_SUCCESS;
	} else  /* ambiguous */
		rstat = DB_NOTUNIQUE;

	WRITEUNLOCK2(this, table, rstat, rstat,
			"wu db_mindex::add",
			"wu table db_mindex::add");
	return (rstat);
}

/* ************************* pickle_mindex ********************* */
/* Does the actual writing to/from file specific for db_mindex structure. */
static bool_t
transfer_aux(XDR* x, pptr rp)
{
	return (xdr_db_mindex(x, (db_mindex*) rp));
}

class pickle_mindex: public pickle_file {
    public:
	pickle_mindex(char *f, pickle_mode m) : pickle_file(f, m) {}

	/* Transfers db_mindex structure pointed to by dp to/from file. */
	int transfer(db_mindex* dp)
		{
			int	ret;

			WRITELOCK(dp, -1, "w pickle_mindex::transfer");
			ret = pickle_file::transfer((pptr) dp, &transfer_aux);
			WRITEUNLOCK(dp, ret, "wu pickle_mindex::transfer");
			return (ret);
		}
};

/* Write this structure (table, indices, scheme) into the specified file. */
int
db_mindex::dump(char *file)
{
	pickle_mindex f(file, PICKLE_WRITE);
	int status = f.transfer(this);

	if (status == 1)
		return (-1); /* could not open for write */
	else
		return (status);
}

/*
 * Reset the table by: deleting all the indices, table of entries, and its
 * scheme.
*/
void
db_mindex::reset()
{
	WRITELOCKV(this, "w db_mindex::reset");
	reset_tables();   /* clear table contents first */

	if (indices.indices_val) {
		delete [] indices.indices_val;
		indices.indices_val = NULL;
	}
	if (table) { delete table; table = NULL;  }
	if (scheme) { delete scheme; scheme = NULL;  }
	indices.indices_len = 0;
	rversion.zero();
	if (objPath.ptr != 0) {
		free(objPath.ptr);
		objPath.ptr = 0;
	}
	WRITEUNLOCKV(this, "wu db_mindex::reset");
}

/*
 * Initialize table using information from specified file.
 * The table is first 'reset', then the attempt to load from the file
 * is made.  If the load failed, the table is again reset.
 * Therefore, the table will be modified regardless of the success of the
 * load.  Returns 0 if successful, 1 if DB disk file couldn't be opened,
 * -1 for various other failures.
*/
int
db_mindex::load(char *file)
{
	pickle_mindex f(file, PICKLE_READ);
	int status;
	int	init_table = (this->table == NULL);
	int	init_scheme = (this->scheme == NULL);

	WRITELOCK(this, -1, "w db_mindex::load");
	reset();

	/* load new mindex */
	if ((status = f.transfer(this)) != 0) {
		/* load failed.  Reset. */
		reset();
	}

	/* Initialize the 'scheme' locking */
	if (status == 0 && this->scheme != 0 && init_scheme) {
		/*
		 * Since we've added fields to the db_scheme that aren't
		 * read from disk, we need to re-allocate so that the
		 * db_scheme instance is large enough.
		 */
		db_scheme	*tmpscheme = new db_scheme();
		if (tmpscheme != 0) {
			(void) memcpy(tmpscheme, this->scheme,
					this->scheme->oldstructsize());
			free(this->scheme);
			this->scheme = tmpscheme;
		} else {
			status = -1;
		}
	}
	/*
	 * If the 'table' field was NULL before the load, but not now,
	 * initialize the table locking and mapping.
	 */
	if (status == 0 && this->table != 0 && init_table) {
		/*
		 * As for the db_scheme, make sure the db_table is large
		 * enough.
		 */
		db_table	*tmptable = new db_table();
		if (tmptable != 0) {
			(void) memcpy(tmptable, this->table,
					this->table->oldstructsize());
			free(this->table);
			this->table = tmptable;
			(void) this->configure(file);
		} else {
			status = -1;
		}
	}

	if (status == 0 && this->indices.indices_val != NULL) {
		/*
		 * Recreate the db_index instance so that it is
		 * correctly initialized.
		 */
		db_index *tmp_indices;
		int	n_index = this->indices.indices_len;

		tmp_indices = new db_index[n_index];
		if (tmp_indices != NULL) {
			for (int i = 0; i < n_index; i++) {
			    if (tmp_indices[i].move_xdr_db_index
				(&this->indices.indices_val[i]) != DB_SUCCESS) {
					status = -1;
					break;
			    }
			}
			free(this->indices.indices_val);
			this->indices.indices_val = tmp_indices;
			this->indices.indices_len = n_index;
		} else {
			status = -1;
		}
	}

	WRITEUNLOCK(this, status, "wu db_mindex::load");
	return (status);
}

/*
 * Prints statistics of the table.  This includes the size of the table,
 * the number of entries, and the index sizes.
 */
void
db_mindex::print_stats()
{
	long size, count, i;
	long *stats = table->stats(TRUE);

	printf("table_size = %d\n", stats[0]);
	printf("last_used = %d\n", stats[1]);
	printf("count = %d\n", stats[2]);
	printf("free list size = %d\n", stats[3]);
	printf("free list count = %d\n", stats[4]);

	for (i = 5; i < 5+stats[4]; i++) {
		printf("%d, ", stats[i]);
	}
	printf("\n");
	free((char *)stats);

	/* Add sanity check in case of corrupted table */
	if (indices.indices_val == NULL) {
		printf("No indices to print\n");
		return;
	}
	for (i = 0; i < indices.indices_len; i++) {
		printf("***** INDEX %d ******\n", i);
		indices.indices_val[i].stats(&size, &count);
		printf("index table size = %d\ncount = %d\n", size, count);
	}
}

/* Prints statistics about all indices of table. */
void
db_mindex::print_all_indices()
{
	int i;

	READLOCKV(this, "r db_mindex::print_all_indices");
	/* Add sanity check in case of corrupted table */
	if (indices.indices_val == NULL) {
		printf("No indices to print\n");
		READUNLOCKV(this, "ru db_mindex::print_all_indices");
		return;
	}
	for (i = 0; i < indices.indices_len; i++) {
		printf("***** INDEX %d ******\n", i);
		indices.indices_val[i].print();
	}
	READUNLOCKV(this, "ru db_mindex::print_all_indices");
}

/* Prints statistics about indices identified by 'n'. */
void
db_mindex::print_index(int n)
{
	READLOCKV(this, "r db_mindex::print_index");
	if (n >= 0 && n < indices.indices_len)
		indices.indices_val[n].print();
	READUNLOCKV(this, "ru db_mindex::print_index");
}