/*
 * 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" */