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


#include <sys/param.h>
#include <strings.h>
#include <syslog.h>
#include "nisdb_mt.h"
#include "db_headers.h"
#include "db_entry.h"
#include "db.h"
#include "db_dictionary.h"
#include "db_pickle.h"
#include "nis_db.h"
#include "nis_ldap.h"
#include "ldap_util.h"
#include "ldap_parse.h"
#include "ldap_glob.h"
#include "ldap_xdr.h"
#include "ldap_glob.h"

db_dictionary	curdict;
db_dictionary	tempdict; /* a temporary one */

db_dictionary *InUseDictionary = &curdict;
db_dictionary *FreeDictionary = &tempdict;

extern "C" {
static db_result	*db_add_entry_x(char *tab, int numattrs,
					nis_attr *attrname, entry_obj * newobj,
					int skiplog, int nosync);
db_status		db_table_exists(char *table_name);

/*
 * (Imported from rpc.nisd/nis_xx_proc.c)
 *
 * 'tbl_prototype' is used to create a table that holds a directory.
 */
static table_col cols[2] = {
	{(char *)"object", TA_BINARY+TA_XDR, 0},
	{(char *)"name", TA_CASE+TA_SEARCHABLE, 0}
};

table_obj tbl_prototype = { (char *)"DIRECTORY", 2, ' ', {2, &cols[0]}, NULL };
}

/*
 * Free resources associated with a db_result structure
 */
void
db_free_result(db_result *dr)
{
	int	i;

	if (dr == 0)
		return;

	/* Can't have valid objects */
	if (dr->status != DB_SUCCESS) {
		free(dr);
		return;
	}

	for (i = 0; i < dr->objects.objects_len; i++)
		free_entry(dr->objects.objects_val[i]);
	free(dr->objects.objects_val);
	free(dr);
}


/* Return an empty db_result structure with its status field set to 's'. */
db_result*
empty_result(db_status s)
{
	db_result * res = new db_result;
	if (res != NULL)  {
		res->status = s;
		res->nextinfo.db_next_desc_len = 0;
		res->nextinfo.db_next_desc_val = NULL;
		res->objects.objects_len = 0;
		res->objects.objects_val = NULL;
	} else {
		WARNING("nis_db::empty_result: cannot allocate space");
	}
	return (res);
}

static db_result*
set_result(db_result* res, db_status s)
{
	if (res != NULL)  {
		res->status = s;
	}
	return (res);
}

/*
 * Given a FQ object name for a table or directory, return the (db *)
 * corresponding to the object.
 */
db *
tableDB(char *tableName) {
	db_table_desc	*tbl = 0;
	char		*intName;
	db		*dbase;

	intName = internalTableName(tableName);
	if (intName == 0)
		return (0);

	dbase = InUseDictionary->find_table(intName, &tbl);

	sfree(intName);

	return (dbase);
}

extern "C" {

bool_t
db_in_dict_file(char *name)
{
	return (InUseDictionary->find_table_desc(name) != NULL);

}

const char
*db_perror(db_status dbstat)
{
	const char *str = NULL;

	switch (dbstat) {
		case DB_SUCCESS:
			str = "Success";
			break;
		case DB_NOTFOUND:
			str = "Not Found";
			break;
		case DB_BADTABLE:
			str = "Bad Table";
			break;
		case DB_BADQUERY:
			str = "Bad Query";
			break;
		case DB_BADOBJECT:
			str = "Bad Object";
			break;
		case DB_MEMORY_LIMIT:
			str = "Memory limit exceeded";
			break;
		case DB_STORAGE_LIMIT:
			str = "Database storage limit exceeded";
			break;
		case DB_INTERNAL_ERROR:
			str = "Database internal error";
			break;
		case DB_SYNC_FAILED:
			str = "Sync of log file failed";
			break;
		default:
			str = "Unknown Error";
			break;
	}
	return (str);
}

bool_t
db_extract_dict_entries(char *newdict, char **fs, int fscnt)
{
	/*
	 * Use the "FreeDictionary" ptr for the backup
	 * dictionary.
	 */
	if (!FreeDictionary->inittemp(newdict, *InUseDictionary))
		return (FALSE);
	return (InUseDictionary->extract_entries (*FreeDictionary,
		fs, fscnt));
}

bool_t
db_copy_file(char *infile, char *outfile)
{
	return (InUseDictionary->copyfile(infile, outfile));

}


/*
 * The tok and repl parameters will allow us to merge two dictionaries
 * that reference tables from different domains (master/replica in live
 * in different domains). If set to NULL, then the dictionary merge is
 * done as normal (no name changing).
 */
db_status
db_begin_merge_dict(char *newdict, char *tok, char *repl)
{
	db_status dbstat;

	/*
	 * It is assumed that InUseDictionary has already been initialized.
	 */
	dbstat = InUseDictionary->checkpoint();
	if (dbstat != DB_SUCCESS)
		return (dbstat);

	/*
	 * Use the "FreeDictionary" ptr for the backup
	 * dictionary.
	 */
	if (!FreeDictionary->init(newdict))
		return (DB_INTERNAL_ERROR);

	return (InUseDictionary->merge_dict(*FreeDictionary,
		tok, repl));
}


db_status
db_end_merge_dict()
{
	db_status	dbstat;

	dbstat = InUseDictionary->checkpoint();
	if (dbstat != DB_SUCCESS) {
		return (dbstat);
	}
	dbstat = InUseDictionary->db_shutdown();
	if (dbstat != DB_SUCCESS) {
		return (dbstat);
	}
	dbstat = FreeDictionary->db_shutdown();
	if (dbstat != DB_SUCCESS) {
		return (dbstat);
	}
	return (dbstat);
}



db_status
db_abort_merge_dict()
{
	db_status	dbstat;

	dbstat = InUseDictionary->db_shutdown();
	if (dbstat != DB_SUCCESS)
		return (dbstat);
	dbstat = FreeDictionary->db_shutdown();
	return (dbstat);
}


/*
 * Initialize system (dictionary) using file 'filename'.  If system cannot
 * be read from file, it is initialized to be empty. Returns TRUE if
 * initialization succeeds, FALSE otherwise.
 * This function must be called before any other.
*/
bool_t
db_initialize(char * filename)
{
	return (InUseDictionary->init(filename));
}


/*
 * Massage the dictionary file by replacing the specified token with the
 * the replacement string. This function is needed to provide backwards
 * compatibility for providing a transportable dictionary file. The idea
 * is that rpc.nisd will call this function when it wants to change the
 * /var/nis/<hostname> strings with something like /var/nis/data.
 *
 */
db_status
db_massage_dict(char *newdictname, char *tok, char *repl)
{
	return (InUseDictionary->massage_dict(newdictname, tok, repl));
}



/*
 * Create new table using given table name and table descriptor.
 * Returns DB_SUCCESS if successful; appropriate error code otherwise.
*/
db_status
db_create_table(char * table_name, table_obj * table_desc)
{
	return (InUseDictionary->add_table(table_name, table_desc));
}

/*
 * Destroys table named by 'table_name.'  Returns DB_SUCCESS if successful,
 * error code otherwise.  Note that currently, the removed table is no
 * longer accessible from this interface and all files associated with it
 * are removed from stable storage.
*/
db_status
db_destroy_table(char * table_name)
{
	return (InUseDictionary->delete_table(table_name));
}


/*
* Return a copy of the first entry in the specified table, that satisfies
* the given attributes.  The returned structure 'db_result' contains the status,
* the  copy of the object, and a 'db_next_desc' to be used for the 'next'
* operation.
 */
db_result *
db_first_entry(char * table_name, int numattrs, nis_attr * attrname)
{
	db_result * safety = empty_result(DB_SUCCESS);
	db_table_desc * tbl = NULL;
	db * dbase = InUseDictionary->find_table(table_name, &tbl);

	if (tbl == NULL || dbase == NULL)
		return (set_result(safety, DB_BADTABLE));
	else {
		db_result * res = NULL;
		db_query *query = NULL;

		if (numattrs != 0) {
			query = InUseDictionary->translate_to_query(tbl,
					numattrs, attrname);
			if (query == NULL)
				return (set_result(safety,
						DB_BADQUERY));
		}
		res = dbase->execute(DB_FIRST, query, NULL, NULL);
		if (query) delete query;
		if (safety) delete safety;
		return (res);
	}
}

/*
 * Return a copy of the next entry in the specified table as specified by
 * the 'next_desc'.  The returned structure 'db_result' contains the status,
 * a copy of the object, and a db_next_desc to be used for a subsequent
 * 'next' operation.
*/
db_result *
db_next_entry(char * table_name, db_next_desc * next_desc)
{
	db_result * safety = empty_result(DB_SUCCESS);
	db * dbase = InUseDictionary->find_table(table_name);

	if (dbase != NULL) {
		if (safety) delete safety;
		return (dbase->execute(DB_NEXT, NULL, NULL, next_desc));
	} else
		return (set_result(safety, DB_BADTABLE));
}

/*
 * Indicate to the system that you are no longer interested in the rest of the
 * results identified by [next_desc].  After executing this operation, the
 * [next_desc] is no longer valid (cannot  be used as an argument for next).
*/

db_result *
db_reset_next_entry(char * table_name, db_next_desc * next_desc)
{
	db_result * safety = empty_result(DB_SUCCESS);
	db * dbase = InUseDictionary->find_table(table_name);

	if (dbase != NULL) {
		if (safety) delete safety;
		return (dbase->execute(DB_RESET_NEXT,
					NULL, NULL, next_desc));
	} else
		return (set_result(safety, DB_BADTABLE));
}

/*
 * Returns copies of entries that satisfy the given attributes from table.
 * Returns the status and entries in a db_result structure.
 * If no attributes are specified, DB_BADQUERY is returned.
*/
db_result *
__db_list_entries(char * table_name, int numattrs, nis_attr * attrname,
			bool_t useDeferred)
{
	db_result * safety = empty_result(DB_SUCCESS);
	db_table_desc * tbl = NULL;
	db * dbase = InUseDictionary->find_table(table_name, &tbl,
							useDeferred);

	if (tbl == NULL || dbase == NULL)
		return (set_result(safety, DB_BADTABLE));
	else {
		db_result * res = NULL;
		if (numattrs != 0) {
			db_query *query;
			query = InUseDictionary->translate_to_query(tbl,
						    numattrs, attrname);
			if (query == NULL)
				return (set_result(safety,
							DB_BADQUERY));
			res = dbase->execute(DB_LOOKUP, query,
							NULL, NULL);
			delete query;
		} else {
			res = dbase->execute(DB_ALL, NULL, NULL, NULL);
		}
		if (safety) delete safety;
		return (res);
	}
}

db_result *
db_list_entries(char *table_name, int numattrs, nis_attr *attrname) {
	return (__db_list_entries(table_name, numattrs, attrname, TRUE));
}

/*
 * Input:	A fully qualified object name (example: "x.y.z").
 * Output:	Returns the first level of the object name ("x").
 *		If 'tableP' is non-NULL, '*tableP' will contain
 *		the internal table name for "y.z".
 *
 * Both the return value and '*tableP' must be freed by the caller.
 */
char *
entryName(const char *msg, char *objName, char **tableP) {
	char		*name, *table, *dir;
	const char	*myself = "entryName";

	if (msg == 0)
		msg = myself;

	name = sdup(msg, T, objName);
	if (name == 0)
		return (0);

	dir = strchr(name, '.');
	if (dir == 0) {
		sfree(name);
		return (0);
	}
	*(dir++) = '\0';

	if (tableP == 0)
		return (name);

	table = internalTableName(dir);
	if (table == 0) {
		sfree(name);
		return (0);
	}

	*tableP = table;

	return (name);
}

#define	RETSTAT(obj, status) \
	{ \
		if (statP != 0) \
			*statP = status; \
		return (obj); \
	}

/*
 * Given a fully qualified object name, retrive a copy of the object,
 * using the NIS+ DB only (i.e., no LDAP). Avoids using nis_leaf_of()
 * etc., since they aren't re-entrant.
 */
nis_object *
dbFindObject(char *objName, db_status *statP) {
	char		buf[MAXPATHLEN+NIS_MAXNAMELEN+1];
	char		*name, *table = 0;
	nis_attr	attr;
	db		*dbase;
	db_result	*res;
	db_table_desc	*tbl = 0;
	db_query	*query;
	db_mindex	*mindex;
	nis_object	*o;
	int		lstat;
	const char	*myself = "dbFindObject";

	if (objName == 0)
		RETSTAT(0, DB_BADQUERY);

	/* The root dir is treated specially */
	table = internalTableName(objName);
	if (table == 0)
		RETSTAT(0, DB_BADQUERY);
	if (strcmp(ROOTDIRFILE, table) == 0) {
		sfree(table);

		o = get_root_object();
		if (o == 0)
			RETSTAT(0, DB_NOTFOUND);

		RETSTAT(o, DB_SUCCESS);
	}

	/* If not the root dir, find the directory where the entry lives */

	sfree(table);
	name = entryName(myself, objName, &table);
	if (name == 0 || table == 0) {
		sfree(name);
		RETSTAT(0, DB_MEMORY_LIMIT);
	}

	dbase = InUseDictionary->find_table_noLDAP(table, &tbl, TRUE, TRUE);
	sfree(table);
	if (dbase != 0)
		mindex = dbase->mindex();
	if (dbase == 0 || tbl == 0 || mindex == 0) {
		sfree(name);
		RETSTAT(0, DB_BADTABLE);
	}

	WRITELOCKNR(mindex, lstat, "mindex w dbFindObject");
	if (lstat != 0) {
		sfree(name);
		RETSTAT(0, DB_LOCK_ERROR);
	}

	attr.zattr_ndx = (char *)"name";
	attr.zattr_val.zattr_val_val = name;
	attr.zattr_val.zattr_val_len = slen(name) + 1;

	query = InUseDictionary->translate_to_query(tbl, 1, &attr);
	if (query == 0) {
		sfree(name);
		WRITEUNLOCKNR(mindex, lstat, "mindex wu dbFindObject");
		RETSTAT(0, DB_BADQUERY);
	}

	/* Only want to look in the local DB */
	mindex->setNoLDAPquery();

	res = dbase->execute(DB_LOOKUP, query, 0, 0);

	mindex->clearNoLDAPquery();

	delete query;

	sfree(name);

	WRITEUNLOCKNR(mindex, lstat, "mindex wu dbFindObject");
	if (lstat != 0) {
		db_free_result(res);
		RETSTAT(0, DB_LOCK_ERROR);
	}

	if (res == 0)
		RETSTAT(0, DB_MEMORY_LIMIT);

	if (res->status != DB_SUCCESS) {
		db_status	st = res->status;

		db_free_result(res);
		RETSTAT(0, st);
	}

	if (res->objects.objects_len != 1 || res->objects.objects_val == 0 ||
			res->objects.objects_val[0] == 0) {
		db_free_result(res);
		RETSTAT(0, DB_BADOBJECT);
	}

	o = unmakePseudoEntryObj(res->objects.objects_val[0], 0);

	db_free_result(res);

	if (o == 0) {
		RETSTAT(0, DB_BADOBJECT);
	}

	RETSTAT(o, DB_SUCCESS);
}

/*
 * Return the object specified by 't' or 'objName' from LDAP. Set
 * the LDAP status in '*statP'.
 */
nis_object *
ldapFindObj(__nis_table_mapping_t *t, char *objName, int *statP) {
	nis_object	*o;
	int		stat;
	const char	*myself = "ldapFindObj";

	if (t == 0) {
		char	*table, tbuf[MAXPATHLEN + NIS_MAXNAMELEN + 1];

		if (objName == 0) {
			if (statP != 0)
				*statP = LDAP_PARAM_ERROR;
			return (0);
		}

		/* Look for mapping */
		table = internal_table_name(objName, tbuf);
		if (table == 0) {
			if (statP != 0)
				*statP = LDAP_PARAM_ERROR;
			return (0);
		}

		t = (__nis_table_mapping_t *)__nis_find_item_mt(table,
						&ldapMappingList, 0, 0);
		if (t == 0) {
			/* Not really an error; just not mapped */
			*statP = LDAP_SUCCESS;
			return (0);
		}
	}

	o = 0;
	stat = objFromLDAP(t, &o, 0, 0);

	if (statP != 0)
		*statP = stat;

	return (o);
}

/*
 * Look for the specified object, first locally, then in LDAP.
 */
nis_object *
findObj(char *name, db_status *statP, int *lstatP) {
	nis_object	*o;
	db_status	stat = DB_SUCCESS;
	int		lstat = LDAP_SUCCESS;
	const char	*myself = "findObj";

	o = dbFindObject(name, &stat);

	if (o == 0) {
		if (stat != DB_NOTFOUND)
			logmsg(MSG_NOTIMECHECK, LOG_INFO,
				"%s: DB error %d looking for \"%s\"",
				myself, stat, NIL(name));

		o = ldapFindObj(0, name, &lstat);
		if (o == 0) {
			if (lstat != LDAP_SUCCESS &&
					lstat != LDAP_NO_SUCH_OBJECT)
				logmsg(MSG_NOTIMECHECK, LOG_INFO,
				"%s: LDAP error looking for \"%s\": %s",
					myself, NIL(name),
					ldap_err2string(lstat));
		}
	}

	if (statP != 0)
		*statP = stat;
	if (lstatP != 0)
		*lstatP = lstat;

	return (o);
}

/*
 * Delete the specified object from the local DB.
 */
db_status
dbDeleteObj(char *objName) {
	nisdb_tsd_t	*tsd = __nisdb_get_tsd();
	nis_object	*o;
	db_status	stat;
	nisdb_obj_del_t	*nod, *tmp;
	int		xid;
	const char	*myself = "dbDeleteObj";

	if (objName == 0)
		return (DB_SUCCESS);

	/*
	 * Since in-structure locks can't completely protect
	 * during structure deletion, we just note that the
	 * object should be deleted, and leave that for a
	 * (slightly) later time in rpc.nisd, where we can
	 * use the rpc.nisd's table/directory locks for
	 * protection.
	 */

	if (tsd == 0)
		return (DB_INTERNAL_ERROR);

	o = dbFindObject(objName, &stat);
	if (o == 0) {
		if (stat == DB_NOTFOUND)
			return (DB_SUCCESS);
		else
			return (stat);
	}

	/*
	 * In order to prevent a chicken-and-egg problem (if the
	 * object doesn't exist in LDAP, is that because we just
	 * haven't written it to LDAP yet, or because it's been
	 * removed), we only allow object deletion if we're the
	 * master for it.
	 */

	nod = (nisdb_obj_del_t *)am(myself, sizeof (*nod));
	if (nod == 0) {
		nis_destroy_object(o);
		return (DB_MEMORY_LIMIT);
	}

	nod->objType = o->zo_data.zo_type;
	nis_destroy_object(o);

	nod->objName = sdup(myself, T, objName);
	if (nod->objName == 0) {
		sfree(nod);
		return (DB_MEMORY_LIMIT);
	}

	/* Check for a dup */
	for (tmp = tsd->objDelList; tmp != 0;
			tmp = (nisdb_obj_del_t *)tmp->next) {
		if (strcmp(nod->objName, tmp->objName) == 0) {
			sfree(nod->objName);
			sfree(nod);
			return (DB_SUCCESS);
		}
	}

	/* Insert at start of list */
	nod->next = tsd->objDelList;
	tsd->objDelList = nod;

	return (DB_SUCCESS);
}

/*
 * Touch (i.e., update the expiration time for) the specified object.
 */
db_status
dbTouchObj(char *objName) {
	char		*ent, *table;
	db		*dbase;
	db_table_desc	*tbl = 0;
	db_mindex	*mindex;
	nis_attr	attr;
	db_query	*query;
	db_status	stat;
	const char	*myself = "dbTouchObj";

	table = internalTableName(objName);
	if (table == 0)
		return (DB_BADQUERY);

	if (strcmp(ROOTDIRFILE, table) == 0) {
		sfree(table);

		if (touchRootDir() == 0)
			return (DB_SUCCESS);
		else
			return (DB_INTERNAL_ERROR);
	}

	sfree(table);
	table = 0;
	ent = entryName(myself, objName, &table);
	if (ent == 0 || table == 0) {
		sfree(ent);
		return (DB_MEMORY_LIMIT);
	}

	dbase = InUseDictionary->find_table(table, &tbl, TRUE);
	if (dbase != 0)
		mindex = dbase->mindex();
	if (dbase == 0 || tbl == 0 || mindex == 0) {
		sfree(ent);
		sfree(table);
		return (DB_BADTABLE);
	}

	attr.zattr_ndx = (char *)"name";
	attr.zattr_val.zattr_val_val = ent;
	attr.zattr_val.zattr_val_len = slen(ent) + 1;

	query = InUseDictionary->translate_to_query(tbl, 1, &attr);
	if (query == 0) {
		sfree(ent);
		sfree(table);
		return (DB_BADQUERY);
	}

	mindex->touchEntry(query);

	sfree(ent);
	sfree(table);
	delete query;

	return (DB_SUCCESS);
}

/*
 * Create a NIS_TABLE_OBJ.
 * Borrows heavily from rpc.nisd/nis_db.c:__create_table().
 */
db_status
dbCreateTable(char *intName, nis_object *obj) {
	table_col	tc[NIS_MAXCOLUMNS+1];
	table_obj	tobj, *t;
	int		i;
	const char	*myself = "dbCreateTable";

	if (intName == 0 || obj == 0)
		return (DB_BADTABLE);

	t = &(obj->TA_data);

	/* Make sure there are searchable columns */
	for (i = 0; i < t->ta_cols.ta_cols_len; i++) {
		if (t->ta_cols.ta_cols_val[i].tc_flags & TA_SEARCHABLE)
			break;
	}
	if (i >= t->ta_cols.ta_cols_len) {
		logmsg(MSG_NOTIMECHECK, LOG_INFO,
			"%s: No searchable columns in \"%s\" (\"%s\")",
			myself, NIL(obj->zo_name), NIL(intName));
		return (DB_BADTABLE);
	}

	tobj = *t;
	/* Shift columns one step right */
	for (i = 0; i < tobj.ta_cols.ta_cols_len; i++) {
		tc[i+1] = tobj.ta_cols.ta_cols_val[i];
	}
	tc[0].tc_name = 0;
	tc[0].tc_flags = TA_XDR | TA_BINARY;
	tc[0].tc_rights = 0;
	tobj.ta_cols.ta_cols_len += 1;
	tobj.ta_cols.ta_cols_val = tc;

	return (db_create_table(intName, &tobj));
}

#define	TABLE_COL(o, n)	o->TA_data.ta_cols.ta_cols_val[n]

/*
 * Refresh (if necessary, create), the specified object in the local DB.
 */
db_status
dbRefreshObj(char *name, nis_object *o) {
	char		*objName;
	__nis_buffer_t	b = {0, 0};
	nis_object	*curObj;
	db_status	stat;
	char		*ent, *table, *objTable;
	int		rstat, isDir = 0, isTable = 0;
	const char	*myself = "refreshObj";

	if (o == 0)
		/* Delete it */
		return (dbDeleteObj(name));

	/* We don't work on entry objects */
	if (o->zo_data.zo_type == NIS_ENTRY_OBJ)
		return (DB_BADOBJECT);

	if (name != 0)
		objName = name;
	else {
		bp2buf(myself, &b, "%s.%s", NIL(o->zo_name), NIL(o->zo_domain));
		objName = b.buf;
	}

	curObj = dbFindObject(objName, &stat);
	if (curObj == 0 && stat != DB_NOTFOUND) {
		sfree(b.buf);
		return (stat);
	}

	/*
	 * If the object doesn't change, just touch it to update the
	 * expiration time.
	 */
	if (curObj != 0) {
		if (sameNisPlusObj(o, curObj)) {
			sfree(b.buf);
			nis_destroy_object(curObj);
			return (dbTouchObj(objName));
		}

		/* Otherwise, check that the name and type is the same */
		if (o->zo_data.zo_type != curObj->zo_data.zo_type ||
			o->zo_name == 0 || curObj->zo_name == 0 ||
			o->zo_domain == 0 || curObj->zo_domain == 0 ||
			strcmp(o->zo_name, curObj->zo_name) != 0 ||
			strcmp(o->zo_domain, curObj->zo_domain) != 0) {
			sfree(b.buf);
			nis_destroy_object(curObj);
			return (DB_BADOBJECT);
		}

		/*
		 * If the object is a table, we can't allow the scheme
		 * to change.
		 */
		if (o->zo_data.zo_type == NIS_TABLE_OBJ) {
			int	i;

			if (o->TA_data.ta_maxcol !=
					curObj->TA_data.ta_maxcol) {
				sfree(b.buf);
				nis_destroy_object(curObj);
				return (DB_BADOBJECT);
			}

			for (i = 0; i < o->TA_data.ta_maxcol; i++) {
				if ((TABLE_COL(o, i).tc_flags &
						TA_SEARCHABLE) !=
					(TABLE_COL(curObj, i).tc_flags &
						TA_SEARCHABLE)) {
					sfree(b.buf);
					nis_destroy_object(curObj);
					return (DB_BADOBJECT);
				}
			}
		}
	} else {
		/*
		 * If we're creating a directory object, make a note
		 * so that we can add it to the serving list and create
		 * the disk file. Similarly, if creating a table, we
		 * also need to create the disk file.
		 */
		if (o->zo_data.zo_type == NIS_DIRECTORY_OBJ)
			isDir = 1;
		else if (o->zo_data.zo_type == NIS_TABLE_OBJ)
			isTable = 1;
	}

	objTable = internalTableName(objName);
	if (objTable == 0) {
		sfree(b.buf);
		if (curObj != 0)
			nis_destroy_object(curObj);
		return (DB_BADQUERY);
	}

	if (strcmp(ROOTDIRFILE, objTable) == 0) {
		sfree(objTable);

		rstat = update_root_object((nis_name)ROOTOBJFILE, o);
		if (rstat == 1)
			stat = DB_SUCCESS;
		else
			stat = DB_INTERNAL_ERROR;
	} else {
		nis_attr	attr;
		entry_object	*e, eo;
		entry_col	ec[2];
		db		*dbase;
		db_table_desc	*tbl = 0;
		db_mindex	*mindex;
		db_result	*dbres;
		int		lstat;

		/* Find parent */
		ent = entryName(myself, objName, &table);
		if (ent == 0 || table == 0) {
			sfree(b.buf);
			sfree(objTable);
			sfree(ent);
			if (curObj != 0)
				nis_destroy_object(curObj);
			return (DB_MEMORY_LIMIT);
		}

		/*
		 * Calling vanilla find_table() here (which might go to
		 * LDAP and recurse back to ourselves) so that it should
		 * work to create a hierarchy of directories.
		 */
		dbase = InUseDictionary->find_table(table, &tbl, TRUE);
		if (dbase != 0)
			mindex = dbase->mindex();
		if (dbase == 0 || tbl == 0 || mindex == 0) {
			sfree(b.buf);
			sfree(objTable);
			sfree(ent);
			sfree(table);
			if (curObj != 0)
				nis_destroy_object(curObj);
			return (DB_BADTABLE);
		}

		/* Construct suitable nis_attr and entry_object */
		attr.zattr_ndx = (char *)"name";
		attr.zattr_val.zattr_val_val = ent;
		attr.zattr_val.zattr_val_len = slen(ent) + 1;

		ec[1].ec_flags = 0;
		ec[1].ec_value.ec_value_val = ent;
		ec[1].ec_value.ec_value_len = attr.zattr_val.zattr_val_len;

		eo.en_type = (char *)"IN_DIRECTORY";
		eo.en_cols.en_cols_val = ec;
		eo.en_cols.en_cols_len = 2;

		e = makePseudoEntryObj(o, &eo, 0);
		if (e == 0) {
			sfree(objTable);
			sfree(table);
			sfree(ent);
			if (curObj != 0)
				nis_destroy_object(curObj);
			return (DB_INTERNAL_ERROR);
		}

		/* Only want to update the local DB */

		WRITELOCKNR(mindex, lstat, "mindex w dbRefreshObj");
		if (lstat != 0) {
			sfree(objTable);
			sfree(table);
			sfree(ent);
			if (curObj != 0)
				nis_destroy_object(curObj);
			return (DB_LOCK_ERROR);
		}
		mindex->setNoWriteThrough();
		mindex->setNoLDAPquery();

		dbres = db_add_entry_x(table, 1, &attr, e, 0, 0);

		mindex->clearNoLDAPquery();
		mindex->clearNoWriteThrough();
		WRITEUNLOCKNR(mindex, lstat, "mindex wu dbRefreshObj");
		if (lstat != 0) {
			sfree(objTable);
			sfree(table);
			sfree(ent);
			if (curObj != 0)
				nis_destroy_object(curObj);
			db_free_result(dbres);
			return (DB_LOCK_ERROR);
		}

		sfree(ent);
		sfree(table);

		if (dbres == 0)
			stat = DB_MEMORY_LIMIT;
		else
			stat = dbres->status;

		db_free_result(dbres);

		/*
		 * If successful so far, add the transaction.
		 */
		if (stat == DB_SUCCESS) {
			int		xid, st;
			db_status	ds;
			nis_object	*dirObj;

			/* Find the directory where this is added */
			dirObj = dbFindObject(o->zo_domain, &ds);
			if (dirObj == 0) {
				sfree(objTable);
				if (curObj != 0)
					nis_destroy_object(curObj);
				return (ds);
			}

			xid = beginTransaction();
			if (xid == 0) {
				sfree(objTable);
				if (curObj != 0)
					nis_destroy_object(curObj);
				nis_destroy_object(dirObj);
				return (DB_INTERNAL_ERROR);
			}

			st = addUpdate((curObj == 0) ? ADD_NAME : MOD_NAME_NEW,
					objName, 0, 0, o, curObj, 0);
			if (st != 0) {
				(void) abort_transaction(xid);
				sfree(objTable);
				if (curObj != 0)
					nis_destroy_object(curObj);
				nis_destroy_object(dirObj);
				return (DB_INTERNAL_ERROR);
			}

			st = endTransaction(xid, dirObj);
			if (st != 0)
				stat = DB_INTERNAL_ERROR;

			if (curObj != 0)
				nis_destroy_object(curObj);
			nis_destroy_object(dirObj);
		}

		/*
		 * If it's a table or directory, create the DB file.
		 * If a directory, also add it to the serving list.
		 */
		if (stat == DB_SUCCESS &&(isDir || isTable)) {
			if (isDir) {
				stat = db_create_table(objTable,
							&tbl_prototype);
			} else {
				stat = dbCreateTable(objTable, o);
			}
		}
		sfree(objTable);
	}

	sfree(b.buf);

	return (stat);
}

/*
 * Replace the object stored with the mapping 't'. Return TRUE if
 * at least one object was replaced, FALSE otherwise.
 */
bool_t
replaceMappingObj(__nis_table_mapping_t *t, nis_object *n) {
	__nis_table_mapping_t	*x;
	nis_object		*old = 0;
	int			assigned = 0;

	/*
	 * The alternate mappings are usually mostly copies
	 * of the original, so we try to make sure that we
	 * don't free the same nis_object twice.
	 */
	for (x = t; x != 0; x = (__nis_table_mapping_t *)x->next) {
		if (old == 0) {
			old = x->obj;
			if (x->obj != 0)
				nis_destroy_object(x->obj);
		} else {
			if (x->obj != old && x->obj != 0)
				nis_destroy_object(x->obj);
		}
		x->obj = n;
		assigned++;
	}

	return (assigned > 0);
}

/*
 * Set object type, column info, and obj for the specified
 * mapping 't' from the object 'o'. Returns zero if 'o' was unused,
 * and should be freed by the caller, larger than zero otherwise.
 */
int
setMappingObjTypeEtc(__nis_table_mapping_t *t, nis_object *o) {
	__nis_table_mapping_t	*x;
	int			ls, ret;
	int	                i;

	if (t == 0 || o == 0)
		return (0);

	t->objType = o->zo_data.zo_type;
	for (x = t; x != 0; x = (__nis_table_mapping_t *)x->next) {
		if (x != t) {
			x->objType = t->objType;
		}
		if (x->objType == NIS_TABLE_OBJ) {
			/*
			 * If we have rules, this mapping is for table entries,
			 * and we need the column names. Otherwise, remove the
			 * column names (if any).
			 */

                        for (i = 0; i < x->numColumns; i++)
			sfree(x->column[i]);
		        sfree(x->column);
			x->column = 0;
			x->numColumns = 0;
		}
	}
	ret = replaceMappingObj(t, o);

	return (ret);
}

/*
 * Retrieve the specified object (internal DB name) from LDAP, and
 * refresh/create as appropriate.
 */
db_status
dbCreateFromLDAP(char *intName, int *ldapStat) {
	__nis_table_mapping_t	*t;
	int			lstat, doDestroy;
	nis_object		*obj = 0;
	db_status		dstat;
	const char		*myself = "dbCreateFromLDAP";

	if (!useLDAPrespository) {
		if (ldapStat != 0)
			*ldapStat = LDAP_SUCCESS;
		return (DB_SUCCESS);
	}

	t = (__nis_table_mapping_t *)__nis_find_item_mt(intName,
							&ldapMappingList,
							0, 0);

	/* No mapping isn't a failure */
	if (t == 0) {
		if (ldapStat != 0)
			*ldapStat = LDAP_SUCCESS;
		return (DB_NOTFOUND);
	}

	lstat = objFromLDAP(t, &obj, 0, 0);
	if (ldapStat != 0)
		*ldapStat = lstat;
	if (lstat != LDAP_SUCCESS)
		return (DB_NOTFOUND);

	/*
	 * If the LDAP operation was successful, but 'obj' is NULL,
	 * there's no mapping for this object, and we're done.
	 */
	if (obj == 0)
		return (DB_SUCCESS);

	/* Update the mapping with object info */
	doDestroy = setMappingObjTypeEtc(t, obj) == 0;

	dstat = dbRefreshObj(t->objName, obj);

	if (doDestroy)
		nis_destroy_object(obj);

	return (dstat);
}

/*
 * Up- (fromLDAP==0) or down- (fromLDAP==1) load all LDAP mapped data.
 * Returns an LDAP error status.
 */
int
loadAllLDAP(int fromLDAP, void *cookie, db_status *dstatP) {
	__nis_table_mapping_t	*t, *start;
	int			stat = LDAP_SUCCESS;
	db_status		dstat = DB_SUCCESS;
	db			*dbase;
	db_table_desc		*tbl = 0;
	db_mindex		*mindex;
	const char		*myself = "loadAllLDAP";

	/*
	 * If the 'cookie' and '*cookie' are non-NULL, start scanning
	 * the mappings from '*cookie'. When we return with an error,
	 * we set '*cookie' to point to the mapping being processed.
	 * This enables our caller to react appropriately, and retry
	 * if desired.
	 *
	 * The cookie is opaque to our caller, who's only allowed to
	 * initialize *cookie to NULL.
	 */
	if (cookie != 0) {
		start = *((__nis_table_mapping_t **)cookie);
		if (start == 0)
			start = ldapMappingSeq;
	} else {
		start = ldapMappingSeq;
	}

	for (t = start; t != 0; t = (__nis_table_mapping_t *)t->seqNext) {
		__nis_table_mapping_t	**tp;
		int			nm;

		if (fromLDAP) {
			/* Are there any mappings for the object proper ? */
			tp = selectTableMapping(t, 0, 0, 1, t->dbId, &nm);
			if (tp != 0 && nm > 0) {
				dstat = dbCreateFromLDAP(t->objPath, &stat);
				if (dstat != DB_SUCCESS) {
					logmsg(MSG_NOTIMECHECK, LOG_ERR,
				"%s: DB error %d creating \"%s\": %s",
						myself, dstat, NIL(t->objName),
						ldap_err2string(stat));
					if (cookie != 0)
						*((__nis_table_mapping_t **)
							cookie) = t;
					if (dstatP != 0)
						*dstatP = dstat;
					else if (stat == LDAP_SUCCESS)
						stat = LDAP_OPERATIONS_ERROR;
					sfree(tp);
					return (stat);
				}
			}
			sfree(tp);

			/* Any mappings for table entries ? */
			tp = selectTableMapping(t, 0, 0, 0, t->dbId, &nm);
			if (tp == 0 || nm <= 0) {
				sfree(tp);
				continue;
			}
			sfree(tp);

			/*
			 * The object itself must exist in the local
			 * DB by now. Get the db_mindex and let
			 * db_mindex::queryLDAP() do the work; if
			 * the object isn't a table, queryLDAP()
			 * will do nothing and return success.
			 */
			dbase = InUseDictionary->find_table(t->objPath,
							&tbl, TRUE);
			if (dbase != 0)
				mindex = dbase->mindex();
			if (dbase == 0 || tbl == 0 || mindex == 0) {
				logmsg(MSG_NOTIMECHECK, LOG_ERR,
				"%s: No local DB entry for \"%s\" (%s:%s)",
					myself, NIL(t->objPath),
					NIL(t->dbId), NIL(t->objName));
				if (cookie != 0)
					*((__nis_table_mapping_t **)cookie) =
						t;
				if (dstatP != 0)
					*dstatP = DB_BADTABLE;
				return ((dstatP != 0) ?
					LDAP_SUCCESS : LDAP_OPERATIONS_ERROR);
			}
			mindex->setInitialLoad();
			stat = mindex->queryLDAP(0, t->dbId, 0);
			mindex->clearInitialLoad();
			if (stat != LDAP_SUCCESS) {
				logmsg(MSG_NOTIMECHECK, LOG_ERR,
			"%s: LDAP error retrieving entries for %s:%s: %s",
					myself, NIL(t->dbId), NIL(t->objName),
					ldap_err2string(stat));
				if (cookie != 0)
					*((__nis_table_mapping_t **)cookie) =
						t;
				if (dstatP != 0)
					*dstatP = DB_SUCCESS;
				return (stat);
			}
		} else {
			nis_object	*obj;
			char		*ent, *objPath;
			int		freeObjPath = 0;

			/*
			 * Up-loading to LDAP, so the object must
			 * already exist in the local DB.
			 */
			obj = dbFindObject(t->objName, &dstat);
			if (obj == 0) {
				if (dstat == DB_NOTFOUND)
					logmsg(MSG_NOTIMECHECK, LOG_WARNING,
		"%s: No local DB object for \"%s\" (%s:%s); skipping up-load",
						myself, NIL(t->objPath),
						NIL(t->dbId),
						NIL(t->objName));
				else
					logmsg(MSG_NOTIMECHECK, LOG_WARNING,
			"%s: DB error %d for \"%s\" (%s:%s); skipping up-load",
						myself, dstat,
						NIL(t->objPath),
						NIL(t->dbId),
						NIL(t->objName));
				continue;
			}

			/*
			 * If it's a table or directory, there will be
			 * a dictionary entry for the object itself.
			 * Otherwise, we need the dictionary entry for
			 * the parent directory.
			 *
			 * For a table, we need the db_mindex for both the
			 * table object itself, as well as for the parent
			 * directory (in order to store table entries).
			 * We start with the latter.
			 */
			if (obj->zo_data.zo_type == NIS_DIRECTORY_OBJ) {
				objPath = t->objPath;
				ent = 0;
			} else {
				objPath = 0;
				ent = entryName(myself, t->objName,
				    &objPath);
				if (ent == 0 || objPath == 0) {
					logmsg(MSG_NOTIMECHECK, LOG_ERR,
	"%s: Error deriving entry/DB-table names for %s:%s; skipping up-load",
						myself, NIL(t->dbId),
						NIL(t->objName));
					sfree(ent);
					sfree(objPath);
					nis_destroy_object(obj);
					obj = 0;
					continue;
				}
				freeObjPath = 1;
			}

			dbase = InUseDictionary->find_table(objPath,
							&tbl, TRUE);
			if (dbase != 0)
				mindex = dbase->mindex();
			if (dbase == 0 || tbl == 0 || mindex == 0) {
				logmsg(MSG_NOTIMECHECK, LOG_WARNING,
		"%s: No local DB entry for \"%s\" (%s:%s); skipping up-load",
					myself, objPath,
					NIL(t->dbId), NIL(t->objName));
				sfree(ent);
				if (freeObjPath)
					sfree(objPath);
				nis_destroy_object(obj);
				obj = 0;
				continue;
			}

			/*
			 * Our next action(s) depend on the object type:
			 *
			 *	directory	Store dir object
			 *
			 *	table		Store table obj, as well
			 *			as any entries in the
			 *			table
			 *
			 *	other		Store object; we need to
			 *			build a db_query specifying
			 *			the first-level name of the
			 *			object.
			 *
			 * storeLDAP() will just do nothing and return
			 * success if we try to, say, store a table object
			 * when only the table entries are mapped. Hence,
			 * we don't have to worry about those distinctions
			 * here.
			 */
			if (obj->zo_data.zo_type == NIS_DIRECTORY_OBJ) {
				stat = mindex->storeLDAP(0, 0, obj, 0, t->dbId);
			} else {
				nis_attr	attr;
				db_query	*q;

				attr.zattr_ndx = (char *)"name";
				attr.zattr_val.zattr_val_val = ent;
				attr.zattr_val.zattr_val_len = slen(ent) + 1;

				q = new db_query(mindex->getScheme(), 1, &attr);
				if (q == 0) {
					logmsg(MSG_NOTIMECHECK, LOG_ERR,
	"%s: error creating db_query for \"%s\" in \"%s\"; skipping up-load",
						myself, ent, objPath);
					sfree(ent);
					if (freeObjPath)
						sfree(objPath);
					nis_destroy_object(obj);
					obj = 0;
					continue;
				}

				stat = mindex->storeLDAP(q, 0, obj, 0, t->dbId);

				delete q;

			}

			sfree(ent);
			if (freeObjPath)
				sfree(objPath);

			if (stat != LDAP_SUCCESS) {
				logmsg(MSG_NOTIMECHECK, LOG_ERR,
			"%s: Error storing %s:%s to LDAP: %s",
					myself, NIL(t->dbId), NIL(t->objName),
					ldap_err2string(stat));
				nis_destroy_object(obj);
				obj = 0;
				if (cookie != 0)
					*((__nis_table_mapping_t **)
						cookie) = t;
				if (dstatP != 0)
					*dstatP = DB_SUCCESS;
				return (stat);
			}

			/* Any mappings for table entries ? */
			tp = selectTableMapping(t, 0, 0, 0, t->dbId, &nm);
			if (tp == 0 || nm <= 0) {
				sfree(tp);
				nis_destroy_object(obj);
				obj = 0;
				continue;
			}
			sfree(tp);

			/*
			 * If it's a table, we also need to store the table
			 * entries.
			 */
			if (obj->zo_data.zo_type == NIS_TABLE_OBJ) {
				tbl = 0;
				dbase = InUseDictionary->find_table(t->objPath,
								&tbl, TRUE);
				if (dbase != 0)
				mindex = dbase->mindex();
				if (dbase == 0 || tbl == 0 || mindex == 0) {
					logmsg(MSG_NOTIMECHECK, LOG_WARNING,
	"%s: No local DB entry for \"%s\" (%s:%s); skipping entry up-load",
						myself, NIL(t->objPath),
						NIL(t->dbId), NIL(t->objName));
					nis_destroy_object(obj);
					obj = 0;
					continue;
				}

				stat = mindex->storeLDAP(0, 0, obj, 0, t->dbId);

				if (stat != LDAP_SUCCESS) {
					logmsg(MSG_NOTIMECHECK, LOG_ERR,
				"%s: Error storing %s:%s entries to LDAP: %s",
						myself, NIL(t->dbId),
						NIL(t->objName),
						ldap_err2string(stat));
					nis_destroy_object(obj);
					obj = 0;
					if (cookie != 0)
						*((__nis_table_mapping_t **)
							cookie) = t;
					if (dstatP != 0)
						*dstatP = DB_SUCCESS;
					return (stat);
				}
			}
			nis_destroy_object(obj);
			obj = 0;
		}
	}

	if (dstatP != 0)
		*dstatP = dstat;
	return (stat);
}

/*
 * Object identified by given attribute name is added to specified table.
 * If object already exists, it is replaced.  If more than one object
 * matches the given attribute name, DB_NOTUNIQUE is returned.
 */
static
db_result *
db_add_entry_x(char * tab, int numattrs, nis_attr * attrname,
		entry_obj * newobj, int skiplog, int nosync)
{
	db_result * safety = empty_result(DB_SUCCESS);
	db_table_desc * tbl = NULL;
	db * dbase = InUseDictionary->find_table(tab, &tbl, FALSE);

	if (tbl == NULL || dbase == NULL) {
		return (set_result(safety, DB_BADTABLE));
	} else if (skiplog) {
		db_result * res;
		res = dbase->execute(DB_ADD_NOLOG, NULL,
			    (entry_object *) newobj, NULL);
		if (safety) delete safety;
		return (res);
	} else {
		db_result *res;
		db_query *
		query = InUseDictionary->translate_to_query(tbl,
						numattrs, attrname);
		if (query == NULL)
			return (set_result(safety, DB_BADQUERY));
		if (nosync)
			res = dbase->execute(DB_ADD_NOSYNC,
				query, (entry_object *) newobj, NULL);
		else
			res = dbase->execute(DB_ADD, query,
				(entry_object *) newobj, NULL);
		delete query;
		if (safety) delete safety;
		return (res);
	}
}

db_result *
db_add_entry(char * tab, int numattrs, nis_attr * attrname,
		entry_obj * newobj)
{
	return (db_add_entry_x(tab, numattrs, attrname, newobj, 0, 0));
}

db_result *
__db_add_entry_nolog(char * tab, int numattrs, nis_attr * attrname,
		entry_obj * newobj)
{
	return (db_add_entry_x(tab, numattrs, attrname, newobj, 1, 0));
}

db_result *
__db_add_entry_nosync(char * tab, int numattrs, nis_attr * attrname,
			entry_obj * newobj)
{
	return (db_add_entry_x(tab, numattrs, attrname, newobj, 0, 1));
}

/*
 * Remove object identified by given attributes from specified table.
 * If no attribute is supplied, all entries in table are removed.
 * If attributes identify more than one object, all objects are removed.
*/

db_result *
db_remove_entry_x(char * table_name, int num_attrs, nis_attr * attrname,
			int nosync)
{
	db_result * safety = empty_result(DB_SUCCESS);
	db_table_desc * tbl = NULL;
	db * dbase = InUseDictionary->find_table(table_name, &tbl, FALSE);
	db_result * res;

	if (tbl == NULL || dbase == NULL)
		return (set_result(safety, DB_BADTABLE));
	else {
		if (num_attrs != 0) {
			db_query *query;
			query = InUseDictionary->translate_to_query(tbl,
					num_attrs, attrname);
			if (query == NULL)
				return (set_result(safety,
						DB_BADQUERY));
			if (nosync)
				res = dbase->execute(DB_REMOVE_NOSYNC,
						query, NULL, NULL);
			else
				res = dbase->execute(DB_REMOVE, query,
						NULL, NULL);
			delete query;
		} else {
			if (nosync)
				res = dbase->execute(DB_REMOVE_NOSYNC,
					NULL, NULL, NULL);
			else
				res = dbase->execute(DB_REMOVE,
					NULL, NULL, NULL);
		}
		if (safety) delete safety;
		return (res);
	}
}

db_result *
db_remove_entry(char * table_name, int num_attrs, nis_attr * attrname)
{
	return (db_remove_entry_x(table_name, num_attrs, attrname, 0));
}

db_result *
__db_remove_entry_nosync(char * table_name, int num_attrs, nis_attr * attrname)
{
	return (db_remove_entry_x(table_name, num_attrs, attrname, 1));
}

/* Return a copy of the version of specified table. */
vers *
db_version(char * table_name)
{
	db * dbase = InUseDictionary->find_table(table_name);

	if (dbase == NULL)
		return (NULL);
	vers* v = new vers(dbase->get_version());
	if (v == NULL)
		WARNING("nis_db::db_version: cannot allocate space");
	return (v);
}

/* Return log entries since (later than) given version 'v' of table. */
db_log_list *
db_log_entries_since(char * table_name, vers * v)
{
	db * dbase = InUseDictionary->find_table(table_name);

	if (dbase == NULL)
		return (NULL);
	return (dbase->get_log_entries_since(v));
}

db_status
db_sync_log(char *table_name) {

	db * dbase = InUseDictionary->find_table(table_name);

	if (dbase == NULL)
		return (DB_BADTABLE);
	return (dbase->sync_log());
}

/*
 * Apply the given update specified in 'entry' to the specified table.
 * Returns DB_SUCCESS if update was executed.
 * Returns DB_NOTFOUND if update occurs too early to be applied.
*/
db_status
db_apply_log_entry(char * table_name, db_log_entry * entry)
{
	db * dbase = InUseDictionary->find_table(table_name, NULL, FALSE);

	if (dbase == NULL)
		return (DB_BADTABLE);
	if (dbase->execute_log_entry(entry))
		return (DB_SUCCESS);   /* got executed */
	else
		return (DB_NOTFOUND);  /* not executed */
}

/*
 * Checkpoint specified table (i.e. incorporate logged updates to main
 * database file).  If table_name is NULL, checkpoint all tables that
 * needs it.
*/
db_status
db_checkpoint(char * table_name)
{
	return (InUseDictionary->db_checkpoint(table_name));
}

/* Print names of tables in system. */
void
db_print_table_names()
{
	int i;
	db_table_names * answer = InUseDictionary->get_table_names();

	if (answer != NULL) {
		for (i = 0; i < answer->db_table_names_len; i++) {
			printf("%s\n", answer->db_table_names_val[i]);
			delete answer->db_table_names_val[i];
		}
		delete answer->db_table_names_val;
		delete answer;
	}
}

/* Print statistics of specified table to stdout. */
db_status
db_stats(char * table_name)
{
	db_table_desc * tbl = NULL;
	db *dbase = InUseDictionary->find_table(table_name, &tbl);

	if (tbl == NULL || dbase == NULL || tbl->scheme == NULL)
		return (DB_BADTABLE);

	dbase->print();
	tbl->scheme->print();
	return (DB_SUCCESS);
}


/* Print statistics of indices of specified table to stdout. */
db_status
db_print_all_indices(char * table_name)
{
	db * dbase = InUseDictionary->find_table(table_name);

	if (dbase == NULL)
		return (DB_BADTABLE);
	dbase->print_all_indices();
	return (DB_SUCCESS);
}

/* Print specified index of table to stdout. */
db_status
db_print_index(char * table_name, int which)
{
	db * dbase = InUseDictionary->find_table(table_name);

	if (dbase == NULL)
		return (DB_BADTABLE);
	dbase->print_index(which);
	return (DB_SUCCESS);
}

/* close open files */
db_status
db_standby(char * table_name)
{
	return (InUseDictionary->db_standby(table_name));
}

/* Returns DB_SUCCESS if table exists; DB_BADTABLE if table does not exist. */
db_status
db_table_exists(char * table_name)
{
	db_table_desc *dbtab = InUseDictionary->find_table_desc(table_name);

	if (dbtab == NULL)
		return (DB_BADTABLE);
	return (DB_SUCCESS);
}

/*
 * Returns DB_SUCCESS if table exists; DB_BADTABLE if table does not exist.
 *  If table already loaded, unload it.
*/
db_status
db_unload_table(char * table_name)
{
	db_table_desc *
	dbtab = InUseDictionary->find_table_desc(table_name);
	if (dbtab == NULL)
		return (DB_BADTABLE);
	// unload
	if (dbtab->database != NULL) {
		delete dbtab->database;
		dbtab->database = NULL;
	}
	return (DB_SUCCESS);
}

/*
 * Put the specified table in deferred mode, which means that updates go
 * to the original table, but reads are satisfied out of a copy (which we
 * make here). Thus, "defer" refers to the table as seen by read requests,
 * since for them, changes are deferred.
 */
db_status
__db_defer(char *table_name) {
	db_status	stat;

	stat = InUseDictionary->defer(table_name);
	return (stat);
}

/*
 * Commit deferred changes for the specified table. I.e., make visible
 * any updates made since the table was deferred.
 */
db_status
__db_commit(char *table_name) {
	db_status	stat;

	stat = InUseDictionary->commit(table_name);
	return (stat);
}

/*
 * Rollback, i.e., return to the state before we entered deferred mode.
 */
db_status
__db_rollback(char *table_name) {
	db_status	stat;

	stat = InUseDictionary->rollback(table_name);
	return (stat);
}

db_status
__db_configure(char *table_name) {
	db_status	stat;
	char		tablePath[MAXPATHLEN + NIS_MAXNAMELEN + 1];
	db		*dbase = InUseDictionary->find_table(table_name, NULL);

	if (dbase == NULL || table_name == 0)
		return (DB_BADTABLE);

	if (strlen(table_name) >= sizeof (tablePath))
		return (DB_BADQUERY);

	if (internal_table_name(table_name, tablePath) == 0)
		return (DB_STORAGE_LIMIT);

	if (dbase->configure(tablePath))
		stat = DB_SUCCESS;
	else
		stat = DB_INTERNAL_ERROR;

	return (stat);
}

/*
 * During some rpc.nisd operations (such as when recovering the trans.log),
 * we don't want to use the LDAP repository, so we provide a main switch.
 * Note that we expect this to be used only when rpc.nisd is single-threaded,
 * so there is no need for synchronization when reading or modifying the
 * value of the main switch.
 */
int	useLDAPrespository = 1;

void
__db_disallowLDAP(void) {
	useLDAPrespository = 0;
}

void
__db_allowLDAP(void) {
	useLDAPrespository = 1;
}

}  /* extern "C" */