xref: /illumos-gate/usr/src/lib/libnisdb/db_table.cc (revision 8d0852b7f8176b2c281cc944010af2b0fecf9fb2)
17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate  * CDDL HEADER START
37c478bd9Sstevel@tonic-gate  *
47c478bd9Sstevel@tonic-gate  * The contents of this file are subject to the terms of the
57c478bd9Sstevel@tonic-gate  * Common Development and Distribution License, Version 1.0 only
67c478bd9Sstevel@tonic-gate  * (the "License").  You may not use this file except in compliance
77c478bd9Sstevel@tonic-gate  * with the License.
87c478bd9Sstevel@tonic-gate  *
97c478bd9Sstevel@tonic-gate  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
107c478bd9Sstevel@tonic-gate  * or http://www.opensolaris.org/os/licensing.
117c478bd9Sstevel@tonic-gate  * See the License for the specific language governing permissions
127c478bd9Sstevel@tonic-gate  * and limitations under the License.
137c478bd9Sstevel@tonic-gate  *
147c478bd9Sstevel@tonic-gate  * When distributing Covered Code, include this CDDL HEADER in each
157c478bd9Sstevel@tonic-gate  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
167c478bd9Sstevel@tonic-gate  * If applicable, add the following below this CDDL HEADER, with the
177c478bd9Sstevel@tonic-gate  * fields enclosed by brackets "[]" replaced with your own identifying
187c478bd9Sstevel@tonic-gate  * information: Portions Copyright [yyyy] [name of copyright owner]
197c478bd9Sstevel@tonic-gate  *
207c478bd9Sstevel@tonic-gate  * CDDL HEADER END
217c478bd9Sstevel@tonic-gate  */
227c478bd9Sstevel@tonic-gate /*
237c478bd9Sstevel@tonic-gate  *	db_table.cc
247c478bd9Sstevel@tonic-gate  *
257c478bd9Sstevel@tonic-gate  * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
267c478bd9Sstevel@tonic-gate  * Use is subject to license terms.
277c478bd9Sstevel@tonic-gate  */
287c478bd9Sstevel@tonic-gate 
297c478bd9Sstevel@tonic-gate #include <stdio.h>
307c478bd9Sstevel@tonic-gate #include <malloc.h>
317c478bd9Sstevel@tonic-gate #include <string.h>
327c478bd9Sstevel@tonic-gate #include <stdlib.h>		/* srand48() */
337c478bd9Sstevel@tonic-gate #include <lber.h>
347c478bd9Sstevel@tonic-gate #include <ldap.h>
357c478bd9Sstevel@tonic-gate #include "db_headers.h"
367c478bd9Sstevel@tonic-gate #include "db_table.h"
377c478bd9Sstevel@tonic-gate #include "db_pickle.h"    /* for dump and load */
387c478bd9Sstevel@tonic-gate #include "db_entry.h"
397c478bd9Sstevel@tonic-gate #include "nisdb_mt.h"
407c478bd9Sstevel@tonic-gate 
417c478bd9Sstevel@tonic-gate #include "ldap_parse.h"
427c478bd9Sstevel@tonic-gate #include "ldap_util.h"
437c478bd9Sstevel@tonic-gate #include "ldap_map.h"
447c478bd9Sstevel@tonic-gate #include "ldap_xdr.h"
457c478bd9Sstevel@tonic-gate #include "nis_hashitem.h"
467c478bd9Sstevel@tonic-gate #include "nisdb_ldap.h"
477c478bd9Sstevel@tonic-gate #include "nis_parse_ldap_conf.h"
487c478bd9Sstevel@tonic-gate 
497c478bd9Sstevel@tonic-gate static time_t	maxTimeT;
507c478bd9Sstevel@tonic-gate 
517c478bd9Sstevel@tonic-gate /*
527c478bd9Sstevel@tonic-gate  * Find the largest (positive) value of time_t.
537c478bd9Sstevel@tonic-gate  *
547c478bd9Sstevel@tonic-gate  * If time_t is unsigned, the largest possible value is just ~0.
557c478bd9Sstevel@tonic-gate  * However, if it's signed, then ~0 is negative. Since lint (for
567c478bd9Sstevel@tonic-gate  * sure), and perhaps the compiler too, dislike comparing an
577c478bd9Sstevel@tonic-gate  * unsigned quantity to see if it's less than zero, we compare
587c478bd9Sstevel@tonic-gate  * to one instead. If negative, the largest possible value is
597c478bd9Sstevel@tonic-gate  * th inverse of 2**(N-1), where N is the number of bits in a
607c478bd9Sstevel@tonic-gate  * time_t.
617c478bd9Sstevel@tonic-gate  */
627c478bd9Sstevel@tonic-gate extern "C" {
637c478bd9Sstevel@tonic-gate static void
647c478bd9Sstevel@tonic-gate __setMaxTimeT(void)
657c478bd9Sstevel@tonic-gate {
667c478bd9Sstevel@tonic-gate 	unsigned char	b[sizeof (time_t)];
677c478bd9Sstevel@tonic-gate 	int		i;
687c478bd9Sstevel@tonic-gate 
697c478bd9Sstevel@tonic-gate 	/* Compute ~0 for an unknown length integer */
707c478bd9Sstevel@tonic-gate 	for (i = 0; i < sizeof (time_t); i++) {
717c478bd9Sstevel@tonic-gate 		b[i] = 0xff;
727c478bd9Sstevel@tonic-gate 	}
737c478bd9Sstevel@tonic-gate 	/* Set maxTimeT to ~0 of appropriate length */
747c478bd9Sstevel@tonic-gate 	(void) memcpy(&maxTimeT, b, sizeof (time_t));
757c478bd9Sstevel@tonic-gate 
767c478bd9Sstevel@tonic-gate 	if (maxTimeT < 1)
777c478bd9Sstevel@tonic-gate 		maxTimeT = ~(1<<((8*sizeof (maxTimeT))-1));
787c478bd9Sstevel@tonic-gate }
797c478bd9Sstevel@tonic-gate #pragma init(__setMaxTimeT)
807c478bd9Sstevel@tonic-gate }
817c478bd9Sstevel@tonic-gate 
827c478bd9Sstevel@tonic-gate /* How much to grow table by */
837c478bd9Sstevel@tonic-gate #define	DB_TABLE_GROWTH_INCREMENT 1024
847c478bd9Sstevel@tonic-gate 
857c478bd9Sstevel@tonic-gate /* 0'th not used; might be confusing. */
867c478bd9Sstevel@tonic-gate #define	DB_TABLE_START 1
877c478bd9Sstevel@tonic-gate 
887c478bd9Sstevel@tonic-gate /* prevents wrap around numbers from being passed */
897c478bd9Sstevel@tonic-gate #define	CALLOC_LIMIT 536870911
907c478bd9Sstevel@tonic-gate 
917c478bd9Sstevel@tonic-gate /* Initial table sizes to use before using 1K increments. */
927c478bd9Sstevel@tonic-gate /* This helps conserve memory usage when there are lots of small tables. */
937c478bd9Sstevel@tonic-gate static int tabsizes[] = {
947c478bd9Sstevel@tonic-gate 	16,
957c478bd9Sstevel@tonic-gate 	128,
967c478bd9Sstevel@tonic-gate 	512,
977c478bd9Sstevel@tonic-gate 	DB_TABLE_GROWTH_INCREMENT,
987c478bd9Sstevel@tonic-gate 	0
997c478bd9Sstevel@tonic-gate 	};
1007c478bd9Sstevel@tonic-gate 
1017c478bd9Sstevel@tonic-gate /* Returns the next size to use for table */
1027c478bd9Sstevel@tonic-gate static long unsigned
1037c478bd9Sstevel@tonic-gate get_new_table_size(long unsigned oldsize)
1047c478bd9Sstevel@tonic-gate {
1057c478bd9Sstevel@tonic-gate 	long unsigned newsize = 0, n;
1067c478bd9Sstevel@tonic-gate 	if (oldsize == 0)
1077c478bd9Sstevel@tonic-gate 		newsize = tabsizes[0];
1087c478bd9Sstevel@tonic-gate 	else {
1097c478bd9Sstevel@tonic-gate 		for (n = 0; newsize = tabsizes[n++]; )
1107c478bd9Sstevel@tonic-gate 			if (oldsize == newsize) {
1117c478bd9Sstevel@tonic-gate 				newsize = tabsizes[n];	/* get next size */
1127c478bd9Sstevel@tonic-gate 				break;
1137c478bd9Sstevel@tonic-gate 			}
1147c478bd9Sstevel@tonic-gate 		if (newsize == 0)
1157c478bd9Sstevel@tonic-gate 			newsize = oldsize + DB_TABLE_GROWTH_INCREMENT;
1167c478bd9Sstevel@tonic-gate 	}
1177c478bd9Sstevel@tonic-gate 	return (newsize);
1187c478bd9Sstevel@tonic-gate }
1197c478bd9Sstevel@tonic-gate 
1207c478bd9Sstevel@tonic-gate 
1217c478bd9Sstevel@tonic-gate /* destructor */
1227c478bd9Sstevel@tonic-gate db_free_list::~db_free_list()
1237c478bd9Sstevel@tonic-gate {
1247c478bd9Sstevel@tonic-gate 	WRITELOCKV(this, "w db_free_list::~db_free_list");
1257c478bd9Sstevel@tonic-gate 	reset();   /* free list entries */
1267c478bd9Sstevel@tonic-gate 	DESTROYRW(free_list);
1277c478bd9Sstevel@tonic-gate }
1287c478bd9Sstevel@tonic-gate 
1297c478bd9Sstevel@tonic-gate void
1307c478bd9Sstevel@tonic-gate db_free_list::reset()
1317c478bd9Sstevel@tonic-gate {
1327c478bd9Sstevel@tonic-gate 	db_free_entry *current, *nextentry;
1337c478bd9Sstevel@tonic-gate 
1347c478bd9Sstevel@tonic-gate 	WRITELOCKV(this, "w db_free_list::reset");
1357c478bd9Sstevel@tonic-gate 	for (current = head; current != NULL; ) {
1367c478bd9Sstevel@tonic-gate 		nextentry = current->next;
1377c478bd9Sstevel@tonic-gate 		delete current;
1387c478bd9Sstevel@tonic-gate 		current = nextentry;
1397c478bd9Sstevel@tonic-gate 	}
1407c478bd9Sstevel@tonic-gate 	head = NULL;
1417c478bd9Sstevel@tonic-gate 	count = 0;
1427c478bd9Sstevel@tonic-gate 	WRITEUNLOCKV(this, "wu db_free_list::reset");
1437c478bd9Sstevel@tonic-gate }
1447c478bd9Sstevel@tonic-gate 
1457c478bd9Sstevel@tonic-gate /* Returns the location of a free entry, or NULL, if there aren't any. */
1467c478bd9Sstevel@tonic-gate entryp
1477c478bd9Sstevel@tonic-gate db_free_list::pop()
1487c478bd9Sstevel@tonic-gate {
1497c478bd9Sstevel@tonic-gate 	WRITELOCK(this, NULL, "w db_free_list::pop");
1507c478bd9Sstevel@tonic-gate 	if (head == NULL) {
1517c478bd9Sstevel@tonic-gate 		WRITEUNLOCK(this, NULL, "wu db_free_list::pop");
1527c478bd9Sstevel@tonic-gate 		return (NULL);
1537c478bd9Sstevel@tonic-gate 	}
1547c478bd9Sstevel@tonic-gate 	db_free_entry* old_head = head;
1557c478bd9Sstevel@tonic-gate 	entryp found = head->where;
1567c478bd9Sstevel@tonic-gate 	head = head->next;
1577c478bd9Sstevel@tonic-gate 	delete old_head;
1587c478bd9Sstevel@tonic-gate 	--count;
1597c478bd9Sstevel@tonic-gate 	WRITEUNLOCK(this, found, "wu db_free_list::pop");
1607c478bd9Sstevel@tonic-gate 	return (found);
1617c478bd9Sstevel@tonic-gate }
1627c478bd9Sstevel@tonic-gate 
1637c478bd9Sstevel@tonic-gate /*
1647c478bd9Sstevel@tonic-gate  * Adds given location to the free list.
1657c478bd9Sstevel@tonic-gate  * Returns TRUE if successful, FALSE otherwise (when out of memory).
1667c478bd9Sstevel@tonic-gate */
1677c478bd9Sstevel@tonic-gate bool_t
1687c478bd9Sstevel@tonic-gate db_free_list::push(entryp tabloc)
1697c478bd9Sstevel@tonic-gate {
1707c478bd9Sstevel@tonic-gate 	db_free_entry * newentry = new db_free_entry;
1717c478bd9Sstevel@tonic-gate 
1727c478bd9Sstevel@tonic-gate 	WRITELOCK(this, FALSE, "w db_free_list::push");
1737c478bd9Sstevel@tonic-gate 	if (newentry == NULL) {
1747c478bd9Sstevel@tonic-gate 		WRITEUNLOCK(this, FALSE, "wu db_free_list::push");
1757c478bd9Sstevel@tonic-gate 	    FATAL3("db_free_list::push: cannot allocation space",
1767c478bd9Sstevel@tonic-gate 		    DB_MEMORY_LIMIT, FALSE);
1777c478bd9Sstevel@tonic-gate 	}
1787c478bd9Sstevel@tonic-gate 	newentry->where = tabloc;
1797c478bd9Sstevel@tonic-gate 	newentry->next = head;
1807c478bd9Sstevel@tonic-gate 	head = newentry;
1817c478bd9Sstevel@tonic-gate 	++count;
1827c478bd9Sstevel@tonic-gate 	WRITEUNLOCK(this, TRUE, "wu db_free_list::push");
1837c478bd9Sstevel@tonic-gate 	return (TRUE);
1847c478bd9Sstevel@tonic-gate }
1857c478bd9Sstevel@tonic-gate 
1867c478bd9Sstevel@tonic-gate /*
1877c478bd9Sstevel@tonic-gate  * Returns in a vector the information in the free list.
1887c478bd9Sstevel@tonic-gate  * Vector returned is of form: [n free cells][n1][n2][loc1], ..[locn].
1897c478bd9Sstevel@tonic-gate  * Leave the first 'n' cells free.
1907c478bd9Sstevel@tonic-gate  * n1 is the number of entries that should be in the freelist.
1917c478bd9Sstevel@tonic-gate  * n2 is the number of entries actually found in the freelist.
1927c478bd9Sstevel@tonic-gate  * [loc1...locn] are the entries.   n2 <= n1 because we never count beyond n1.
1937c478bd9Sstevel@tonic-gate  * It is up to the caller to free the returned vector when he is through.
1947c478bd9Sstevel@tonic-gate */
1957c478bd9Sstevel@tonic-gate long *
1967c478bd9Sstevel@tonic-gate db_free_list::stats(int nslots)
1977c478bd9Sstevel@tonic-gate {
1987c478bd9Sstevel@tonic-gate 	long	realcount = 0,
1997c478bd9Sstevel@tonic-gate 		i,
2007c478bd9Sstevel@tonic-gate 		liststart = nslots,		// start of freelist
2017c478bd9Sstevel@tonic-gate 		listend = nslots+count+2;	// end of freelist
2027c478bd9Sstevel@tonic-gate 	db_free_entry_p current = head;
2037c478bd9Sstevel@tonic-gate 
2047c478bd9Sstevel@tonic-gate 	READLOCK(this, NULL, "r db_free_list::stats");
2057c478bd9Sstevel@tonic-gate 
2067c478bd9Sstevel@tonic-gate 	long *answer = (long *)malloc((int)(listend)*sizeof (long));
2077c478bd9Sstevel@tonic-gate 	if (answer == 0) {
2087c478bd9Sstevel@tonic-gate 		READUNLOCK(this, NULL, "ru db_free_list::stats");
2097c478bd9Sstevel@tonic-gate 		FATAL3("db_free_list::stats:  cannot allocation space",
2107c478bd9Sstevel@tonic-gate 		    DB_MEMORY_LIMIT, NULL);
2117c478bd9Sstevel@tonic-gate 	}
2127c478bd9Sstevel@tonic-gate 
2137c478bd9Sstevel@tonic-gate 	answer[liststart] = count;  /* size of freelist */
2147c478bd9Sstevel@tonic-gate 
2157c478bd9Sstevel@tonic-gate 	for (i = liststart+2; i < listend && current != NULL; i++) {
2167c478bd9Sstevel@tonic-gate 		answer[i] = current->where;
2177c478bd9Sstevel@tonic-gate 		current = current->next;
2187c478bd9Sstevel@tonic-gate 		++realcount;
2197c478bd9Sstevel@tonic-gate 	}
2207c478bd9Sstevel@tonic-gate 
2217c478bd9Sstevel@tonic-gate 	answer[liststart+1] = realcount;
2227c478bd9Sstevel@tonic-gate 	READUNLOCK(this, answer, "ru db_free_list::stats");
2237c478bd9Sstevel@tonic-gate 	return (answer);
2247c478bd9Sstevel@tonic-gate }
2257c478bd9Sstevel@tonic-gate 
2267c478bd9Sstevel@tonic-gate 
2277c478bd9Sstevel@tonic-gate /* Set default values for the mapping structure */
2287c478bd9Sstevel@tonic-gate void
2297c478bd9Sstevel@tonic-gate db_table::initMappingStruct(__nisdb_table_mapping_t *m) {
2307c478bd9Sstevel@tonic-gate 	if (m == 0)
2317c478bd9Sstevel@tonic-gate 		return;
2327c478bd9Sstevel@tonic-gate 
2337c478bd9Sstevel@tonic-gate 	m->initTtlLo = (ldapDBTableMapping.initTtlLo > 0) ?
2347c478bd9Sstevel@tonic-gate 			ldapDBTableMapping.initTtlLo : (3600-1800);
2357c478bd9Sstevel@tonic-gate 	m->initTtlHi = (ldapDBTableMapping.initTtlHi > 0) ?
2367c478bd9Sstevel@tonic-gate 			ldapDBTableMapping.initTtlHi : (3600+1800);
2377c478bd9Sstevel@tonic-gate 	m->ttl = (ldapDBTableMapping.ttl > 0) ?
2387c478bd9Sstevel@tonic-gate 			ldapDBTableMapping.ttl : 3600;
2397c478bd9Sstevel@tonic-gate 	m->enumExpire = 0;
2407c478bd9Sstevel@tonic-gate 	m->fromLDAP = FALSE;
2417c478bd9Sstevel@tonic-gate 	m->toLDAP = FALSE;
2427c478bd9Sstevel@tonic-gate 	m->isMaster = FALSE;
2437c478bd9Sstevel@tonic-gate 	m->retrieveError = ldapDBTableMapping.retrieveError;
2447c478bd9Sstevel@tonic-gate 	m->retrieveErrorRetry.attempts =
2457c478bd9Sstevel@tonic-gate 		ldapDBTableMapping.retrieveErrorRetry.attempts;
2467c478bd9Sstevel@tonic-gate 	m->retrieveErrorRetry.timeout =
2477c478bd9Sstevel@tonic-gate 		ldapDBTableMapping.retrieveErrorRetry.timeout;
2487c478bd9Sstevel@tonic-gate 	m->storeError = ldapDBTableMapping.storeError;
2497c478bd9Sstevel@tonic-gate 	m->storeErrorRetry.attempts =
2507c478bd9Sstevel@tonic-gate 		ldapDBTableMapping.storeErrorRetry.attempts;
2517c478bd9Sstevel@tonic-gate 	m->storeErrorRetry.timeout =
2527c478bd9Sstevel@tonic-gate 		ldapDBTableMapping.storeErrorRetry.timeout;
2537c478bd9Sstevel@tonic-gate 	m->storeErrorDisp = ldapDBTableMapping.storeErrorDisp;
2547c478bd9Sstevel@tonic-gate 	m->refreshError = ldapDBTableMapping.refreshError;
2557c478bd9Sstevel@tonic-gate 	m->refreshErrorRetry.attempts =
2567c478bd9Sstevel@tonic-gate 		ldapDBTableMapping.refreshErrorRetry.attempts;
2577c478bd9Sstevel@tonic-gate 	m->refreshErrorRetry.timeout =
2587c478bd9Sstevel@tonic-gate 		ldapDBTableMapping.refreshErrorRetry.timeout;
2597c478bd9Sstevel@tonic-gate 	m->matchFetch = ldapDBTableMapping.matchFetch;
2607c478bd9Sstevel@tonic-gate 
2617c478bd9Sstevel@tonic-gate 	if (mapping.expire != 0)
2627c478bd9Sstevel@tonic-gate 		free(mapping.expire);
2637c478bd9Sstevel@tonic-gate 	m->expire = 0;
2647c478bd9Sstevel@tonic-gate 
2657c478bd9Sstevel@tonic-gate 	if (m->tm != 0)
2667c478bd9Sstevel@tonic-gate 		free(m->tm);
2677c478bd9Sstevel@tonic-gate 	m->tm = 0;
2687c478bd9Sstevel@tonic-gate 
2697c478bd9Sstevel@tonic-gate 	/*
2707c478bd9Sstevel@tonic-gate 	 * The 'objType' field obviously indicates the type of object.
2717c478bd9Sstevel@tonic-gate 	 * However, we also use it to tell us if we've retrieved mapping
2727c478bd9Sstevel@tonic-gate 	 * data from LDAP or not; in the latter case, 'objType' is
2737c478bd9Sstevel@tonic-gate 	 * NIS_BOGUS_OBJ. For purposes of maintaining expiration times,
2747c478bd9Sstevel@tonic-gate 	 * we may need to know if the object is a table or a directory
2757c478bd9Sstevel@tonic-gate 	 * _before_ we've retrieved any mapping data. Hence the 'expireType'
2767c478bd9Sstevel@tonic-gate 	 * field, which starts as NIS_BOGUS_OBJ (meaning, don't know, assume
2777c478bd9Sstevel@tonic-gate 	 * directory for now), and later is set to NIS_DIRECTORY_OBJ
2787c478bd9Sstevel@tonic-gate 	 * (always keep expiration data, in case one of the dir entries
2797c478bd9Sstevel@tonic-gate 	 * is mapped) or NIS_TABLE_OBJ (only need expiration data if
2807c478bd9Sstevel@tonic-gate 	 * tha table is mapped).
2817c478bd9Sstevel@tonic-gate 	 */
2827c478bd9Sstevel@tonic-gate 	m->objType = NIS_BOGUS_OBJ;
2837c478bd9Sstevel@tonic-gate 	m->expireType = NIS_BOGUS_OBJ;
2847c478bd9Sstevel@tonic-gate 	if (m->objName != 0)
2857c478bd9Sstevel@tonic-gate 		free(m->objName);
2867c478bd9Sstevel@tonic-gate 	m->objName = 0;
2877c478bd9Sstevel@tonic-gate }
2887c478bd9Sstevel@tonic-gate 
2897c478bd9Sstevel@tonic-gate void
2907c478bd9Sstevel@tonic-gate db_table::db_table_ldap_init(void) {
2917c478bd9Sstevel@tonic-gate 
2927c478bd9Sstevel@tonic-gate 	INITRW(table);
2937c478bd9Sstevel@tonic-gate 
2947c478bd9Sstevel@tonic-gate 	enumMode.flag = 0;
2957c478bd9Sstevel@tonic-gate 	enumCount.flag = 0;
2967c478bd9Sstevel@tonic-gate 	enumIndex.ptr = 0;
2977c478bd9Sstevel@tonic-gate 	enumArray.ptr = 0;
2987c478bd9Sstevel@tonic-gate 
2997c478bd9Sstevel@tonic-gate 	mapping.expire = 0;
3007c478bd9Sstevel@tonic-gate 	mapping.tm = 0;
3017c478bd9Sstevel@tonic-gate 	mapping.objName = 0;
3027c478bd9Sstevel@tonic-gate 	mapping.isDeferredTable = FALSE;
3037c478bd9Sstevel@tonic-gate 	(void) mutex_init(&mapping.enumLock, 0, 0);
3047c478bd9Sstevel@tonic-gate 	mapping.enumTid = 0;
3057c478bd9Sstevel@tonic-gate 	mapping.enumStat = -1;
3067c478bd9Sstevel@tonic-gate 	mapping.enumDeferred = 0;
3077c478bd9Sstevel@tonic-gate 	mapping.enumEntries = 0;
3087c478bd9Sstevel@tonic-gate 	mapping.enumTime = 0;
3097c478bd9Sstevel@tonic-gate }
3107c478bd9Sstevel@tonic-gate 
3117c478bd9Sstevel@tonic-gate /* db_table constructor */
3127c478bd9Sstevel@tonic-gate db_table::db_table() : freelist()
3137c478bd9Sstevel@tonic-gate {
3147c478bd9Sstevel@tonic-gate 	tab = NULL;
3157c478bd9Sstevel@tonic-gate 	table_size = 0;
3167c478bd9Sstevel@tonic-gate 	last_used = 0;
3177c478bd9Sstevel@tonic-gate 	count = 0;
3187c478bd9Sstevel@tonic-gate 
3197c478bd9Sstevel@tonic-gate 	db_table_ldap_init();
3207c478bd9Sstevel@tonic-gate 	initMappingStruct(&mapping);
3217c478bd9Sstevel@tonic-gate 
3227c478bd9Sstevel@tonic-gate /*  grow(); */
3237c478bd9Sstevel@tonic-gate }
3247c478bd9Sstevel@tonic-gate 
3257c478bd9Sstevel@tonic-gate /*
3267c478bd9Sstevel@tonic-gate  * db_table destructor:
3277c478bd9Sstevel@tonic-gate  * 1.  Get rid of contents of freelist
3287c478bd9Sstevel@tonic-gate  * 2.  delete all entries hanging off table
3297c478bd9Sstevel@tonic-gate  * 3.  get rid of table itself
3307c478bd9Sstevel@tonic-gate */
3317c478bd9Sstevel@tonic-gate db_table::~db_table()
3327c478bd9Sstevel@tonic-gate {
3337c478bd9Sstevel@tonic-gate 	WRITELOCKV(this, "w db_table::~db_table");
3347c478bd9Sstevel@tonic-gate 	reset();
3357c478bd9Sstevel@tonic-gate 	DESTROYRW(table);
3367c478bd9Sstevel@tonic-gate }
3377c478bd9Sstevel@tonic-gate 
3387c478bd9Sstevel@tonic-gate /* reset size and pointers */
3397c478bd9Sstevel@tonic-gate void
3407c478bd9Sstevel@tonic-gate db_table::reset()
3417c478bd9Sstevel@tonic-gate {
3427c478bd9Sstevel@tonic-gate 	int i, done = 0;
3437c478bd9Sstevel@tonic-gate 
3447c478bd9Sstevel@tonic-gate 	WRITELOCKV(this, "w db_table::reset");
3457c478bd9Sstevel@tonic-gate 	freelist.reset();
3467c478bd9Sstevel@tonic-gate 
3477c478bd9Sstevel@tonic-gate 	/* Add sanity check in case of table corruption */
3487c478bd9Sstevel@tonic-gate 	if (tab != NULL) {
3497c478bd9Sstevel@tonic-gate 		for (i = 0;
3507c478bd9Sstevel@tonic-gate 			i <= last_used && i < table_size && done < count;
3517c478bd9Sstevel@tonic-gate 			i++) {
3527c478bd9Sstevel@tonic-gate 			if (tab[i]) {
3537c478bd9Sstevel@tonic-gate 				free_entry(tab[i]);
3547c478bd9Sstevel@tonic-gate 				++done;
3557c478bd9Sstevel@tonic-gate 			}
3567c478bd9Sstevel@tonic-gate 		}
3577c478bd9Sstevel@tonic-gate 	}
3587c478bd9Sstevel@tonic-gate 
3597c478bd9Sstevel@tonic-gate 	delete tab;
3607c478bd9Sstevel@tonic-gate 	table_size = last_used = count = 0;
3617c478bd9Sstevel@tonic-gate 	tab = NULL;
3627c478bd9Sstevel@tonic-gate 	sfree(mapping.expire);
3637c478bd9Sstevel@tonic-gate 	mapping.expire = NULL;
3647c478bd9Sstevel@tonic-gate 	mapping.objType = NIS_BOGUS_OBJ;
3657c478bd9Sstevel@tonic-gate 	mapping.expireType = NIS_BOGUS_OBJ;
3667c478bd9Sstevel@tonic-gate 	sfree(mapping.objName);
3677c478bd9Sstevel@tonic-gate 	mapping.objName = 0;
3687c478bd9Sstevel@tonic-gate 	/* Leave other values of the mapping structure unchanged */
3697c478bd9Sstevel@tonic-gate 	enumMode.flag = 0;
3707c478bd9Sstevel@tonic-gate 	enumCount.flag = 0;
3717c478bd9Sstevel@tonic-gate 	sfree(enumIndex.ptr);
3727c478bd9Sstevel@tonic-gate 	enumIndex.ptr = 0;
3737c478bd9Sstevel@tonic-gate 	sfree(enumArray.ptr);
3747c478bd9Sstevel@tonic-gate 	enumArray.ptr = 0;
3757c478bd9Sstevel@tonic-gate 	WRITEUNLOCKV(this, "wu db_table::reset");
3767c478bd9Sstevel@tonic-gate }
3777c478bd9Sstevel@tonic-gate 
3787c478bd9Sstevel@tonic-gate db_status
3797c478bd9Sstevel@tonic-gate db_table::allocateExpire(long oldSize, long newSize) {
3807c478bd9Sstevel@tonic-gate 	time_t			*newExpire;
3817c478bd9Sstevel@tonic-gate 
3827c478bd9Sstevel@tonic-gate 	newExpire = (time_t *)realloc(mapping.expire,
3837c478bd9Sstevel@tonic-gate 				newSize * sizeof (mapping.expire[0]));
3847c478bd9Sstevel@tonic-gate 	if (newExpire != NULL) {
3857c478bd9Sstevel@tonic-gate 		/* Initialize new portion */
3867c478bd9Sstevel@tonic-gate 		(void) memset(&newExpire[oldSize], 0,
3877c478bd9Sstevel@tonic-gate 				(newSize-oldSize) * sizeof (newExpire[0]));
3887c478bd9Sstevel@tonic-gate 		mapping.expire = newExpire;
3897c478bd9Sstevel@tonic-gate 	} else {
3907c478bd9Sstevel@tonic-gate 		return (DB_MEMORY_LIMIT);
3917c478bd9Sstevel@tonic-gate 	}
3927c478bd9Sstevel@tonic-gate 
3937c478bd9Sstevel@tonic-gate 	return (DB_SUCCESS);
3947c478bd9Sstevel@tonic-gate }
3957c478bd9Sstevel@tonic-gate 
3967c478bd9Sstevel@tonic-gate db_status
3977c478bd9Sstevel@tonic-gate db_table::allocateEnumArray(long oldSize, long newSize) {
3987c478bd9Sstevel@tonic-gate 	entry_object	**newEnumArray;
399*8d0852b7SRichard Lowe 	const char	*myself = "db_table::allocateEnumArray";
4007c478bd9Sstevel@tonic-gate 
4017c478bd9Sstevel@tonic-gate 	if (enumCount.flag > 0) {
4027c478bd9Sstevel@tonic-gate 		if (enumIndex.ptr == 0) {
4037c478bd9Sstevel@tonic-gate 			enumIndex.ptr = (entryp *)am(myself, enumCount.flag *
4047c478bd9Sstevel@tonic-gate 						sizeof (entryp));
4057c478bd9Sstevel@tonic-gate 			if (enumIndex.ptr == 0)
4067c478bd9Sstevel@tonic-gate 				return (DB_MEMORY_LIMIT);
4077c478bd9Sstevel@tonic-gate 		}
4087c478bd9Sstevel@tonic-gate 		oldSize = 0;
4097c478bd9Sstevel@tonic-gate 		newSize = enumCount.flag;
4107c478bd9Sstevel@tonic-gate 	}
4117c478bd9Sstevel@tonic-gate 	newEnumArray = (entry_object **)realloc(enumArray.ptr,
4127c478bd9Sstevel@tonic-gate 			newSize * sizeof (entry_object *));
4137c478bd9Sstevel@tonic-gate 	if (newEnumArray != 0 && newSize > oldSize) {
4147c478bd9Sstevel@tonic-gate 		(void) memcpy(&newEnumArray[oldSize], &tab[oldSize],
4157c478bd9Sstevel@tonic-gate 			(newSize-oldSize) * sizeof (entry_object *));
4167c478bd9Sstevel@tonic-gate 		enumArray.ptr = newEnumArray;
4177c478bd9Sstevel@tonic-gate 	} else if (newEnumArray == 0) {
4187c478bd9Sstevel@tonic-gate 		return (DB_MEMORY_LIMIT);
4197c478bd9Sstevel@tonic-gate 	}
4207c478bd9Sstevel@tonic-gate 
4217c478bd9Sstevel@tonic-gate 	return (DB_SUCCESS);
4227c478bd9Sstevel@tonic-gate }
4237c478bd9Sstevel@tonic-gate 
4247c478bd9Sstevel@tonic-gate /* Expand the table.  Fatal error if insufficient memory. */
4257c478bd9Sstevel@tonic-gate void
4267c478bd9Sstevel@tonic-gate db_table::grow()
4277c478bd9Sstevel@tonic-gate {
4287c478bd9Sstevel@tonic-gate 	WRITELOCKV(this, "w db_table::grow");
4297c478bd9Sstevel@tonic-gate 	long oldsize = table_size;
4307c478bd9Sstevel@tonic-gate 	entry_object_p *oldtab = tab;
4317c478bd9Sstevel@tonic-gate 	long i;
4327c478bd9Sstevel@tonic-gate 
4337c478bd9Sstevel@tonic-gate 	table_size = get_new_table_size(oldsize);
4347c478bd9Sstevel@tonic-gate 
4357c478bd9Sstevel@tonic-gate #ifdef DEBUG
4367c478bd9Sstevel@tonic-gate 	fprintf(stderr, "db_table GROWING to %d\n", table_size);
4377c478bd9Sstevel@tonic-gate #endif
4387c478bd9Sstevel@tonic-gate 
4397c478bd9Sstevel@tonic-gate 	if (table_size > CALLOC_LIMIT) {
4407c478bd9Sstevel@tonic-gate 		table_size = oldsize;
4417c478bd9Sstevel@tonic-gate 		WRITEUNLOCKV(this, "wu db_table::grow");
4427c478bd9Sstevel@tonic-gate 		FATAL("db_table::grow: table size exceeds calloc limit",
4437c478bd9Sstevel@tonic-gate 			DB_MEMORY_LIMIT);
4447c478bd9Sstevel@tonic-gate 	}
4457c478bd9Sstevel@tonic-gate 
4467c478bd9Sstevel@tonic-gate //  if ((tab = new entry_object_p[table_size]) == NULL)
4477c478bd9Sstevel@tonic-gate 	if ((tab = (entry_object_p*)
4487c478bd9Sstevel@tonic-gate 		calloc((unsigned int) table_size,
4497c478bd9Sstevel@tonic-gate 			sizeof (entry_object_p))) == NULL) {
4507c478bd9Sstevel@tonic-gate 		tab = oldtab;		// restore previous table info
4517c478bd9Sstevel@tonic-gate 		table_size = oldsize;
4527c478bd9Sstevel@tonic-gate 		WRITEUNLOCKV(this, "wu db_table::grow");
4537c478bd9Sstevel@tonic-gate 		FATAL("db_table::grow: cannot allocate space", DB_MEMORY_LIMIT);
4547c478bd9Sstevel@tonic-gate 	}
4557c478bd9Sstevel@tonic-gate 
4567c478bd9Sstevel@tonic-gate 	/*
4577c478bd9Sstevel@tonic-gate 	 * For directories, we may need the expire time array even if the
4587c478bd9Sstevel@tonic-gate 	 * directory itself isn't mapped. If the objType and expireType both
4597c478bd9Sstevel@tonic-gate 	 * are bogus, we don't  know yet if this is a table or a directory,
4607c478bd9Sstevel@tonic-gate 	 * and must proceed accordingly.
4617c478bd9Sstevel@tonic-gate 	 */
4627c478bd9Sstevel@tonic-gate 	if (mapping.objType == NIS_DIRECTORY_OBJ ||
4637c478bd9Sstevel@tonic-gate 			mapping.expireType != NIS_TABLE_OBJ ||
4647c478bd9Sstevel@tonic-gate 			mapping.fromLDAP) {
4657c478bd9Sstevel@tonic-gate 		db_status stat = allocateExpire(oldsize, table_size);
4667c478bd9Sstevel@tonic-gate 		if (stat != DB_SUCCESS) {
4677c478bd9Sstevel@tonic-gate 			free(tab);
4687c478bd9Sstevel@tonic-gate 			tab = oldtab;
4697c478bd9Sstevel@tonic-gate 			table_size = oldsize;
4707c478bd9Sstevel@tonic-gate 			WRITEUNLOCKV(this, "wu db_table::grow expire");
4717c478bd9Sstevel@tonic-gate 			FATAL(
4727c478bd9Sstevel@tonic-gate 		"db_table::grow: cannot allocate space for expire", stat);
4737c478bd9Sstevel@tonic-gate 		}
4747c478bd9Sstevel@tonic-gate 	}
4757c478bd9Sstevel@tonic-gate 
4767c478bd9Sstevel@tonic-gate 	if (oldtab != NULL) {
4777c478bd9Sstevel@tonic-gate 		for (i = 0; i < oldsize; i++) { // transfer old to new
4787c478bd9Sstevel@tonic-gate 			tab[i] = oldtab[i];
4797c478bd9Sstevel@tonic-gate 		}
4807c478bd9Sstevel@tonic-gate 		delete oldtab;
4817c478bd9Sstevel@tonic-gate 	}
4827c478bd9Sstevel@tonic-gate 
4837c478bd9Sstevel@tonic-gate 	if (enumMode.flag) {
4847c478bd9Sstevel@tonic-gate 		db_status stat = allocateEnumArray(oldsize, table_size);
4857c478bd9Sstevel@tonic-gate 		if (stat != DB_SUCCESS) {
4867c478bd9Sstevel@tonic-gate 			free(tab);
4877c478bd9Sstevel@tonic-gate 			tab = oldtab;
4887c478bd9Sstevel@tonic-gate 			table_size = oldsize;
4897c478bd9Sstevel@tonic-gate 			WRITEUNLOCKV(this, "wu db_table::grow enumArray");
4907c478bd9Sstevel@tonic-gate 			FATAL(
4917c478bd9Sstevel@tonic-gate 		"db_table::grow: cannot allocate space for enumArray", stat);
4927c478bd9Sstevel@tonic-gate 		}
4937c478bd9Sstevel@tonic-gate 	}
4947c478bd9Sstevel@tonic-gate 
4957c478bd9Sstevel@tonic-gate 	WRITEUNLOCKV(this, "wu db_table::grow");
4967c478bd9Sstevel@tonic-gate }
4977c478bd9Sstevel@tonic-gate 
4987c478bd9Sstevel@tonic-gate /*
4997c478bd9Sstevel@tonic-gate  * Return the first entry in table, also return its position in
5007c478bd9Sstevel@tonic-gate  * 'where'.  Return NULL in both if no next entry is found.
5017c478bd9Sstevel@tonic-gate  */
5027c478bd9Sstevel@tonic-gate entry_object*
5037c478bd9Sstevel@tonic-gate db_table::first_entry(entryp * where)
5047c478bd9Sstevel@tonic-gate {
5057c478bd9Sstevel@tonic-gate 	ASSERTRHELD(table);
5067c478bd9Sstevel@tonic-gate 	if (count == 0 || tab == NULL) {  /* empty table */
5077c478bd9Sstevel@tonic-gate 		*where = NULL;
5087c478bd9Sstevel@tonic-gate 		return (NULL);
5097c478bd9Sstevel@tonic-gate 	} else {
5107c478bd9Sstevel@tonic-gate 		entryp i;
5117c478bd9Sstevel@tonic-gate 		for (i = DB_TABLE_START;
5127c478bd9Sstevel@tonic-gate 			i < table_size && i <= last_used; i++) {
5137c478bd9Sstevel@tonic-gate 			if (tab[i] != NULL) {
5147c478bd9Sstevel@tonic-gate 				*where = i;
5157c478bd9Sstevel@tonic-gate 				return (tab[i]);
5167c478bd9Sstevel@tonic-gate 			}
5177c478bd9Sstevel@tonic-gate 		}
5187c478bd9Sstevel@tonic-gate 	}
5197c478bd9Sstevel@tonic-gate 	*where = NULL;
5207c478bd9Sstevel@tonic-gate 	return (NULL);
5217c478bd9Sstevel@tonic-gate }
5227c478bd9Sstevel@tonic-gate 
5237c478bd9Sstevel@tonic-gate /*
5247c478bd9Sstevel@tonic-gate  * Return the next entry in table from 'prev', also return its position in
5257c478bd9Sstevel@tonic-gate  * 'newentry'.  Return NULL in both if no next entry is found.
5267c478bd9Sstevel@tonic-gate  */
5277c478bd9Sstevel@tonic-gate entry_object *
5287c478bd9Sstevel@tonic-gate db_table::next_entry(entryp prev, entryp* newentry)
5297c478bd9Sstevel@tonic-gate {
5307c478bd9Sstevel@tonic-gate 	long i;
5317c478bd9Sstevel@tonic-gate 
5327c478bd9Sstevel@tonic-gate 	ASSERTRHELD(table);
5337c478bd9Sstevel@tonic-gate 	if (prev >= table_size || tab == NULL || tab[prev] == NULL)
5347c478bd9Sstevel@tonic-gate 		return (NULL);
5357c478bd9Sstevel@tonic-gate 	for (i = prev+1; i < table_size && i <= last_used; i++) {
5367c478bd9Sstevel@tonic-gate 		if (tab[i] != NULL) {
5377c478bd9Sstevel@tonic-gate 			*newentry = i;
5387c478bd9Sstevel@tonic-gate 			return (tab[i]);
5397c478bd9Sstevel@tonic-gate 		}
5407c478bd9Sstevel@tonic-gate 	}
5417c478bd9Sstevel@tonic-gate 	*newentry = NULL;
5427c478bd9Sstevel@tonic-gate 	return (NULL);
5437c478bd9Sstevel@tonic-gate }
5447c478bd9Sstevel@tonic-gate 
5457c478bd9Sstevel@tonic-gate /* Return entry at location 'where', NULL if location is invalid. */
5467c478bd9Sstevel@tonic-gate entry_object *
5477c478bd9Sstevel@tonic-gate db_table::get_entry(entryp where)
5487c478bd9Sstevel@tonic-gate {
5497c478bd9Sstevel@tonic-gate 	ASSERTRHELD(table);
5507c478bd9Sstevel@tonic-gate 	if (where < table_size && tab != NULL && tab[where] != NULL)
5517c478bd9Sstevel@tonic-gate 		return (tab[where]);
5527c478bd9Sstevel@tonic-gate 	else
5537c478bd9Sstevel@tonic-gate 		return (NULL);
5547c478bd9Sstevel@tonic-gate }
5557c478bd9Sstevel@tonic-gate 
5567c478bd9Sstevel@tonic-gate void
5577c478bd9Sstevel@tonic-gate db_table::setEntryExp(entryp where, entry_obj *obj, int initialLoad) {
5587c478bd9Sstevel@tonic-gate 	nis_object		*o;
559*8d0852b7SRichard Lowe 	const char		*myself = "db_table::setEntryExp";
5607c478bd9Sstevel@tonic-gate 
5617c478bd9Sstevel@tonic-gate 	/*
5627c478bd9Sstevel@tonic-gate 	 * If we don't know what type of object this is yet, we
5637c478bd9Sstevel@tonic-gate 	 * can find out now. If it's a directory, the pseudo-object
5647c478bd9Sstevel@tonic-gate 	 * in column zero will have the type "IN_DIRECTORY";
5657c478bd9Sstevel@tonic-gate 	 * otherwise, it's a table object.
5667c478bd9Sstevel@tonic-gate 	 */
5677c478bd9Sstevel@tonic-gate 	if (mapping.expireType == NIS_BOGUS_OBJ) {
5687c478bd9Sstevel@tonic-gate 		if (obj != 0) {
5697c478bd9Sstevel@tonic-gate 			if (obj->en_type != 0 &&
5707c478bd9Sstevel@tonic-gate 				strcmp(obj->en_type, "IN_DIRECTORY") == 0) {
5717c478bd9Sstevel@tonic-gate 				mapping.expireType = NIS_DIRECTORY_OBJ;
5727c478bd9Sstevel@tonic-gate 			} else {
5737c478bd9Sstevel@tonic-gate 				mapping.expireType = NIS_TABLE_OBJ;
5747c478bd9Sstevel@tonic-gate 				if (!mapping.fromLDAP) {
5757c478bd9Sstevel@tonic-gate 					free(mapping.expire);
5767c478bd9Sstevel@tonic-gate 					mapping.expire = 0;
5777c478bd9Sstevel@tonic-gate 				}
5787c478bd9Sstevel@tonic-gate 			}
5797c478bd9Sstevel@tonic-gate 		}
5807c478bd9Sstevel@tonic-gate 	}
5817c478bd9Sstevel@tonic-gate 
5827c478bd9Sstevel@tonic-gate 	/* Set the entry TTL */
5837c478bd9Sstevel@tonic-gate 	if (mapping.expire != NULL) {
5847c478bd9Sstevel@tonic-gate 		struct timeval	now;
5857c478bd9Sstevel@tonic-gate 		time_t		lo, hi, ttl;
5867c478bd9Sstevel@tonic-gate 
5877c478bd9Sstevel@tonic-gate 		(void) gettimeofday(&now, NULL);
5887c478bd9Sstevel@tonic-gate 		if (mapping.expireType == NIS_TABLE_OBJ) {
5897c478bd9Sstevel@tonic-gate 			lo = mapping.initTtlLo;
5907c478bd9Sstevel@tonic-gate 			hi = mapping.initTtlHi;
5917c478bd9Sstevel@tonic-gate 			ttl = mapping.ttl;
5927c478bd9Sstevel@tonic-gate 			/* TTL == 0 means always expired */
5937c478bd9Sstevel@tonic-gate 			if (ttl == 0)
5947c478bd9Sstevel@tonic-gate 				ttl = -1;
5957c478bd9Sstevel@tonic-gate 		} else {
5967c478bd9Sstevel@tonic-gate 			__nis_table_mapping_t	*t = 0;
5977c478bd9Sstevel@tonic-gate 
5987c478bd9Sstevel@tonic-gate 			o = unmakePseudoEntryObj(obj, 0);
5997c478bd9Sstevel@tonic-gate 			if (o != 0) {
6007c478bd9Sstevel@tonic-gate 				__nis_buffer_t	b = {0, 0};
6017c478bd9Sstevel@tonic-gate 
6027c478bd9Sstevel@tonic-gate 				bp2buf(myself, &b, "%s.%s",
6037c478bd9Sstevel@tonic-gate 					o->zo_name, o->zo_domain);
6047c478bd9Sstevel@tonic-gate 				t = getObjMapping(b.buf, 0, 1, 0, 0);
6057c478bd9Sstevel@tonic-gate 				sfree(b.buf);
6067c478bd9Sstevel@tonic-gate 				nis_destroy_object(o);
6077c478bd9Sstevel@tonic-gate 			}
6087c478bd9Sstevel@tonic-gate 
6097c478bd9Sstevel@tonic-gate 			if (t != 0) {
6107c478bd9Sstevel@tonic-gate 				lo = t->initTtlLo;
6117c478bd9Sstevel@tonic-gate 				hi = t->initTtlHi;
6127c478bd9Sstevel@tonic-gate 				ttl = t->ttl;
6137c478bd9Sstevel@tonic-gate 				/* TTL == 0 means always expired */
6147c478bd9Sstevel@tonic-gate 				if (ttl == 0)
6157c478bd9Sstevel@tonic-gate 					ttl = -1;
6167c478bd9Sstevel@tonic-gate 			} else {
6177c478bd9Sstevel@tonic-gate 				/*
6187c478bd9Sstevel@tonic-gate 				 * No expiration time initialization
6197c478bd9Sstevel@tonic-gate 				 * data. Cook up values that will
6207c478bd9Sstevel@tonic-gate 				 * result in mapping.expire[where]
6217c478bd9Sstevel@tonic-gate 				 * set to maxTimeT.
6227c478bd9Sstevel@tonic-gate 				 */
6237c478bd9Sstevel@tonic-gate 				hi = lo = ttl = maxTimeT - now.tv_sec;
6247c478bd9Sstevel@tonic-gate 			}
6257c478bd9Sstevel@tonic-gate 		}
6267c478bd9Sstevel@tonic-gate 
6277c478bd9Sstevel@tonic-gate 		if (initialLoad) {
6287c478bd9Sstevel@tonic-gate 			int	interval = hi - lo + 1;
6297c478bd9Sstevel@tonic-gate 			if (interval <= 1) {
6307c478bd9Sstevel@tonic-gate 				mapping.expire[where] = now.tv_sec + lo;
6317c478bd9Sstevel@tonic-gate 			} else {
6327c478bd9Sstevel@tonic-gate 				srand48(now.tv_sec);
6337c478bd9Sstevel@tonic-gate 				mapping.expire[where] = now.tv_sec +
6347c478bd9Sstevel@tonic-gate 							(lrand48() % interval);
6357c478bd9Sstevel@tonic-gate 			}
6367c478bd9Sstevel@tonic-gate 			if (mapping.enumExpire == 0 ||
6377c478bd9Sstevel@tonic-gate 					mapping.expire[where] <
6387c478bd9Sstevel@tonic-gate 							mapping.enumExpire)
6397c478bd9Sstevel@tonic-gate 				mapping.enumExpire = mapping.expire[where];
6407c478bd9Sstevel@tonic-gate 		} else {
6417c478bd9Sstevel@tonic-gate 			mapping.expire[where] = now.tv_sec + ttl;
6427c478bd9Sstevel@tonic-gate 		}
6437c478bd9Sstevel@tonic-gate 	}
6447c478bd9Sstevel@tonic-gate }
6457c478bd9Sstevel@tonic-gate 
6467c478bd9Sstevel@tonic-gate /*
6477c478bd9Sstevel@tonic-gate  * Add given entry to table in first available slot (either look in freelist
6487c478bd9Sstevel@tonic-gate  * or add to end of table) and return the the position of where the record
6497c478bd9Sstevel@tonic-gate  * is placed. 'count' is incremented if entry is added. Table may grow
6507c478bd9Sstevel@tonic-gate  * as a side-effect of the addition. Copy is made of input.
6517c478bd9Sstevel@tonic-gate */
6527c478bd9Sstevel@tonic-gate entryp
6537c478bd9Sstevel@tonic-gate db_table::add_entry(entry_object *obj, int initialLoad) {
6547c478bd9Sstevel@tonic-gate 	/*
6557c478bd9Sstevel@tonic-gate 	 * We're returning an index of the table array, so the caller
6567c478bd9Sstevel@tonic-gate 	 * should hold a lock until done with the index. To save us
6577c478bd9Sstevel@tonic-gate 	 * the bother of upgrading to a write lock, it might as well
6587c478bd9Sstevel@tonic-gate 	 * be a write lock to begin with.
6597c478bd9Sstevel@tonic-gate 	 */
6607c478bd9Sstevel@tonic-gate 	ASSERTWHELD(table);
6617c478bd9Sstevel@tonic-gate 	entryp where = freelist.pop();
6627c478bd9Sstevel@tonic-gate 	if (where == NULL) {				/* empty freelist */
6637c478bd9Sstevel@tonic-gate 		if (last_used >= (table_size-1))	/* full (> is for 0) */
6647c478bd9Sstevel@tonic-gate 			grow();
6657c478bd9Sstevel@tonic-gate 		where = ++last_used;
6667c478bd9Sstevel@tonic-gate 	}
6677c478bd9Sstevel@tonic-gate 	if (tab != NULL) {
6687c478bd9Sstevel@tonic-gate 		++count;
6697c478bd9Sstevel@tonic-gate 		setEntryExp(where, obj, initialLoad);
6707c478bd9Sstevel@tonic-gate 
6717c478bd9Sstevel@tonic-gate 		if (enumMode.flag)
6727c478bd9Sstevel@tonic-gate 			enumTouch(where);
6737c478bd9Sstevel@tonic-gate 		tab[where] = new_entry(obj);
6747c478bd9Sstevel@tonic-gate 		return (where);
6757c478bd9Sstevel@tonic-gate 	} else {
6767c478bd9Sstevel@tonic-gate 		return (NULL);
6777c478bd9Sstevel@tonic-gate 	}
6787c478bd9Sstevel@tonic-gate }
6797c478bd9Sstevel@tonic-gate 
6807c478bd9Sstevel@tonic-gate /*
6817c478bd9Sstevel@tonic-gate  * Replaces object at specified location by given entry.
6827c478bd9Sstevel@tonic-gate  * Returns TRUE if replacement successful; FALSE otherwise.
6837c478bd9Sstevel@tonic-gate  * There must something already at the specified location, otherwise,
6847c478bd9Sstevel@tonic-gate  * replacement fails. Copy is not made of the input.
6857c478bd9Sstevel@tonic-gate  * The pre-existing entry is freed.
6867c478bd9Sstevel@tonic-gate  */
6877c478bd9Sstevel@tonic-gate bool_t
6887c478bd9Sstevel@tonic-gate db_table::replace_entry(entryp where, entry_object * obj)
6897c478bd9Sstevel@tonic-gate {
6907c478bd9Sstevel@tonic-gate 	ASSERTWHELD(table);
6917c478bd9Sstevel@tonic-gate 	if (where < DB_TABLE_START || where >= table_size ||
6927c478bd9Sstevel@tonic-gate 	    tab == NULL || tab[where] == NULL)
6937c478bd9Sstevel@tonic-gate 		return (FALSE);
6947c478bd9Sstevel@tonic-gate 	/* (Re-)set the entry TTL */
6957c478bd9Sstevel@tonic-gate 	setEntryExp(where, obj, 0);
6967c478bd9Sstevel@tonic-gate 
6977c478bd9Sstevel@tonic-gate 	if (enumMode.flag)
6987c478bd9Sstevel@tonic-gate 		enumTouch(where);
6997c478bd9Sstevel@tonic-gate 	free_entry(tab[where]);
7007c478bd9Sstevel@tonic-gate 	tab[where] = obj;
7017c478bd9Sstevel@tonic-gate 	return (TRUE);
7027c478bd9Sstevel@tonic-gate }
7037c478bd9Sstevel@tonic-gate 
7047c478bd9Sstevel@tonic-gate /*
7057c478bd9Sstevel@tonic-gate  * Deletes entry at specified location.  Returns TRUE if location is valid;
7067c478bd9Sstevel@tonic-gate  * FALSE if location is invalid, or the freed location cannot be added to
7077c478bd9Sstevel@tonic-gate  * the freelist.  'count' is decremented if the deletion occurs.  The object
7087c478bd9Sstevel@tonic-gate  * at that location is freed.
7097c478bd9Sstevel@tonic-gate  */
7107c478bd9Sstevel@tonic-gate bool_t
7117c478bd9Sstevel@tonic-gate db_table::delete_entry(entryp where)
7127c478bd9Sstevel@tonic-gate {
7137c478bd9Sstevel@tonic-gate 	bool_t	ret = TRUE;
7147c478bd9Sstevel@tonic-gate 
7157c478bd9Sstevel@tonic-gate 	ASSERTWHELD(table);
7167c478bd9Sstevel@tonic-gate 	if (where < DB_TABLE_START || where >= table_size ||
7177c478bd9Sstevel@tonic-gate 	    tab == NULL || tab[where] == NULL)
7187c478bd9Sstevel@tonic-gate 		return (FALSE);
7197c478bd9Sstevel@tonic-gate 	if (mapping.expire != NULL) {
7207c478bd9Sstevel@tonic-gate 		mapping.expire[where] = 0;
7217c478bd9Sstevel@tonic-gate 	}
7227c478bd9Sstevel@tonic-gate 	if (enumMode.flag)
7237c478bd9Sstevel@tonic-gate 		enumTouch(where);
7247c478bd9Sstevel@tonic-gate 	free_entry(tab[where]);
7257c478bd9Sstevel@tonic-gate 	tab[where] = NULL;    /* very important to set it to null */
7267c478bd9Sstevel@tonic-gate 	--count;
7277c478bd9Sstevel@tonic-gate 	if (where == last_used) { /* simple case, deleting from end */
7287c478bd9Sstevel@tonic-gate 		--last_used;
7297c478bd9Sstevel@tonic-gate 		return (TRUE);
7307c478bd9Sstevel@tonic-gate 	} else {
7317c478bd9Sstevel@tonic-gate 		return (freelist.push(where));
7327c478bd9Sstevel@tonic-gate 	}
7337c478bd9Sstevel@tonic-gate 	return (ret);
7347c478bd9Sstevel@tonic-gate }
7357c478bd9Sstevel@tonic-gate 
7367c478bd9Sstevel@tonic-gate /*
7377c478bd9Sstevel@tonic-gate  * Returns statistics of table.
7387c478bd9Sstevel@tonic-gate  * [vector_size][table_size][last_used][count][freelist].
7397c478bd9Sstevel@tonic-gate  * It is up to the caller to free the returned vector when his is through.
7407c478bd9Sstevel@tonic-gate  * The free list is included if 'fl' is TRUE.
7417c478bd9Sstevel@tonic-gate */
7427c478bd9Sstevel@tonic-gate long *
7437c478bd9Sstevel@tonic-gate db_table::stats(bool_t include_freelist)
7447c478bd9Sstevel@tonic-gate {
7457c478bd9Sstevel@tonic-gate 	long *answer;
7467c478bd9Sstevel@tonic-gate 
7477c478bd9Sstevel@tonic-gate 	READLOCK(this, NULL, "r db_table::stats");
7487c478bd9Sstevel@tonic-gate 	if (include_freelist)
7497c478bd9Sstevel@tonic-gate 		answer = freelist.stats(3);
7507c478bd9Sstevel@tonic-gate 	else {
7517c478bd9Sstevel@tonic-gate 		answer = (long *)malloc(3*sizeof (long));
7527c478bd9Sstevel@tonic-gate 	}
7537c478bd9Sstevel@tonic-gate 
7547c478bd9Sstevel@tonic-gate 	if (answer) {
7557c478bd9Sstevel@tonic-gate 		answer[0] = table_size;
7567c478bd9Sstevel@tonic-gate 		answer[1] = last_used;
7577c478bd9Sstevel@tonic-gate 		answer[2] = count;
7587c478bd9Sstevel@tonic-gate 	}
7597c478bd9Sstevel@tonic-gate 	READUNLOCK(this, answer, "ru db_table::stats");
7607c478bd9Sstevel@tonic-gate 	return (answer);
7617c478bd9Sstevel@tonic-gate }
7627c478bd9Sstevel@tonic-gate 
7637c478bd9Sstevel@tonic-gate bool_t
7647c478bd9Sstevel@tonic-gate db_table::configure(char *tablePath) {
7657c478bd9Sstevel@tonic-gate 	long		i;
7667c478bd9Sstevel@tonic-gate 	struct timeval	now;
767*8d0852b7SRichard Lowe 	const char	*myself = "db_table::configure";
7687c478bd9Sstevel@tonic-gate 
7697c478bd9Sstevel@tonic-gate 	(void) gettimeofday(&now, NULL);
7707c478bd9Sstevel@tonic-gate 
7717c478bd9Sstevel@tonic-gate 	WRITELOCK(this, FALSE, "db_table::configure w");
7727c478bd9Sstevel@tonic-gate 
7737c478bd9Sstevel@tonic-gate 	/* (Re-)initialize from global info */
7747c478bd9Sstevel@tonic-gate 	initMappingStruct(&mapping);
7757c478bd9Sstevel@tonic-gate 
7767c478bd9Sstevel@tonic-gate 	/* Retrieve table mapping for this table */
7777c478bd9Sstevel@tonic-gate 	mapping.tm = (__nis_table_mapping_t *)__nis_find_item_mt(
7787c478bd9Sstevel@tonic-gate 					tablePath, &ldapMappingList, 0, 0);
7797c478bd9Sstevel@tonic-gate 	if (mapping.tm != 0) {
7807c478bd9Sstevel@tonic-gate 		__nis_object_dn_t	*odn = mapping.tm->objectDN;
7817c478bd9Sstevel@tonic-gate 
7827c478bd9Sstevel@tonic-gate 		/*
7837c478bd9Sstevel@tonic-gate 		 * The mapping.fromLDAP and mapping.toLDAP fields serve as
7847c478bd9Sstevel@tonic-gate 		 * quick-references that tell us if mapping is enabled.
7857c478bd9Sstevel@tonic-gate 		 * Hence, initialize them appropriately from the table
7867c478bd9Sstevel@tonic-gate 		 * mapping objectDN.
7877c478bd9Sstevel@tonic-gate 		 */
7887c478bd9Sstevel@tonic-gate 		while (odn != 0 && (!mapping.fromLDAP || !mapping.toLDAP)) {
7897c478bd9Sstevel@tonic-gate 			if (odn->read.scope != LDAP_SCOPE_UNKNOWN)
7907c478bd9Sstevel@tonic-gate 				mapping.fromLDAP = TRUE;
7917c478bd9Sstevel@tonic-gate 			if (odn->write.scope != LDAP_SCOPE_UNKNOWN)
7927c478bd9Sstevel@tonic-gate 				mapping.toLDAP = TRUE;
7937c478bd9Sstevel@tonic-gate 			odn = (__nis_object_dn_t *)odn->next;
7947c478bd9Sstevel@tonic-gate 		}
7957c478bd9Sstevel@tonic-gate 
7967c478bd9Sstevel@tonic-gate 		/* Set the timeout values */
7977c478bd9Sstevel@tonic-gate 		mapping.initTtlLo = mapping.tm->initTtlLo;
7987c478bd9Sstevel@tonic-gate 		mapping.initTtlHi = mapping.tm->initTtlHi;
7997c478bd9Sstevel@tonic-gate 		mapping.ttl = mapping.tm->ttl;
8007c478bd9Sstevel@tonic-gate 
8017c478bd9Sstevel@tonic-gate 		mapping.objName = sdup(myself, T, mapping.tm->objName);
8027c478bd9Sstevel@tonic-gate 		if (mapping.objName == 0 && mapping.tm->objName != 0) {
8037c478bd9Sstevel@tonic-gate 			WRITEUNLOCK(this, FALSE,
8047c478bd9Sstevel@tonic-gate 				"db_table::configure wu objName");
8057c478bd9Sstevel@tonic-gate 			FATAL3("db_table::configure objName",
8067c478bd9Sstevel@tonic-gate 				DB_MEMORY_LIMIT, FALSE);
8077c478bd9Sstevel@tonic-gate 		}
8087c478bd9Sstevel@tonic-gate 	}
8097c478bd9Sstevel@tonic-gate 
8107c478bd9Sstevel@tonic-gate 	/*
8117c478bd9Sstevel@tonic-gate 	 * In order to initialize the expiration times, we need to know
8127c478bd9Sstevel@tonic-gate 	 * if 'this' represents a table or a directory. To that end, we
8137c478bd9Sstevel@tonic-gate 	 * find an entry in the table, and invoke setEntryExp() on it.
8147c478bd9Sstevel@tonic-gate 	 * As a side effect, setEntryExp() will examine the pseudo-object
8157c478bd9Sstevel@tonic-gate 	 * in the entry, and set the expireType accordingly.
8167c478bd9Sstevel@tonic-gate 	 */
8177c478bd9Sstevel@tonic-gate 	if (tab != 0) {
8187c478bd9Sstevel@tonic-gate 		for (i = 0; i <= last_used; i++) {
8197c478bd9Sstevel@tonic-gate 			if (tab[i] != NULL) {
8207c478bd9Sstevel@tonic-gate 				setEntryExp(i, tab[i], 1);
8217c478bd9Sstevel@tonic-gate 				break;
8227c478bd9Sstevel@tonic-gate 			}
8237c478bd9Sstevel@tonic-gate 		}
8247c478bd9Sstevel@tonic-gate 	}
8257c478bd9Sstevel@tonic-gate 
8267c478bd9Sstevel@tonic-gate 	/*
8277c478bd9Sstevel@tonic-gate 	 * If mapping from an LDAP repository, make sure we have the
8287c478bd9Sstevel@tonic-gate 	 * expiration time array.
8297c478bd9Sstevel@tonic-gate 	 */
8307c478bd9Sstevel@tonic-gate 	if ((mapping.expireType != NIS_TABLE_OBJ || mapping.fromLDAP) &&
8317c478bd9Sstevel@tonic-gate 			mapping.expire == NULL && table_size > 0 && tab != 0) {
8327c478bd9Sstevel@tonic-gate 		db_status stat = allocateExpire(0, table_size);
8337c478bd9Sstevel@tonic-gate 		if (stat != DB_SUCCESS) {
8347c478bd9Sstevel@tonic-gate 			WRITEUNLOCK(this, FALSE,
8357c478bd9Sstevel@tonic-gate 				"db_table::configure wu expire");
8367c478bd9Sstevel@tonic-gate 			FATAL3("db_table::configure expire",
8377c478bd9Sstevel@tonic-gate 				stat, FALSE);
8387c478bd9Sstevel@tonic-gate 		}
8397c478bd9Sstevel@tonic-gate 	} else if (mapping.expireType == NIS_TABLE_OBJ && !mapping.fromLDAP &&
8407c478bd9Sstevel@tonic-gate 			mapping.expire != NULL) {
8417c478bd9Sstevel@tonic-gate 		/* Not using expiration times */
8427c478bd9Sstevel@tonic-gate 		free(mapping.expire);
8437c478bd9Sstevel@tonic-gate 		mapping.expire = NULL;
8447c478bd9Sstevel@tonic-gate 	}
8457c478bd9Sstevel@tonic-gate 
8467c478bd9Sstevel@tonic-gate 	/*
8477c478bd9Sstevel@tonic-gate 	 * Set initial expire times for entries that don't already have one.
8487c478bd9Sstevel@tonic-gate 	 * Establish the enumeration expiration time to be the minimum of
8497c478bd9Sstevel@tonic-gate 	 * all expiration times in the table, though no larger than current
8507c478bd9Sstevel@tonic-gate 	 * time plus initTtlHi.
8517c478bd9Sstevel@tonic-gate 	 */
8527c478bd9Sstevel@tonic-gate 	if (mapping.expire != NULL) {
8537c478bd9Sstevel@tonic-gate 		int	interval = mapping.initTtlHi - mapping.initTtlLo + 1;
8547c478bd9Sstevel@tonic-gate 		time_t	enumXp = now.tv_sec + mapping.initTtlHi;
8557c478bd9Sstevel@tonic-gate 
8567c478bd9Sstevel@tonic-gate 		if (interval > 1)
8577c478bd9Sstevel@tonic-gate 			srand48(now.tv_sec);
8587c478bd9Sstevel@tonic-gate 		for (i = 0; i <= last_used; i++) {
8597c478bd9Sstevel@tonic-gate 			if (tab[i] != NULL && mapping.expire[i] == 0) {
8607c478bd9Sstevel@tonic-gate 				if (mapping.expireType == NIS_TABLE_OBJ) {
8617c478bd9Sstevel@tonic-gate 					if (interval > 1)
8627c478bd9Sstevel@tonic-gate 						mapping.expire[i] =
8637c478bd9Sstevel@tonic-gate 							now.tv_sec +
8647c478bd9Sstevel@tonic-gate 							(lrand48() % interval);
8657c478bd9Sstevel@tonic-gate 					else
8667c478bd9Sstevel@tonic-gate 						mapping.expire[i] =
8677c478bd9Sstevel@tonic-gate 							now.tv_sec +
8687c478bd9Sstevel@tonic-gate 							mapping.initTtlLo;
8697c478bd9Sstevel@tonic-gate 				} else {
8707c478bd9Sstevel@tonic-gate 					setEntryExp(i, tab[i], 1);
8717c478bd9Sstevel@tonic-gate 				}
8727c478bd9Sstevel@tonic-gate 			}
8737c478bd9Sstevel@tonic-gate 			if (enumXp > mapping.expire[i])
8747c478bd9Sstevel@tonic-gate 				enumXp = mapping.expire[i];
8757c478bd9Sstevel@tonic-gate 		}
8767c478bd9Sstevel@tonic-gate 		mapping.enumExpire = enumXp;
8777c478bd9Sstevel@tonic-gate 	}
8787c478bd9Sstevel@tonic-gate 
8797c478bd9Sstevel@tonic-gate 	WRITEUNLOCK(this, FALSE, "db_table::configure wu");
8807c478bd9Sstevel@tonic-gate 
8817c478bd9Sstevel@tonic-gate 	return (TRUE);
8827c478bd9Sstevel@tonic-gate }
8837c478bd9Sstevel@tonic-gate 
8847c478bd9Sstevel@tonic-gate /* Return TRUE if the entry at 'loc' hasn't expired */
8857c478bd9Sstevel@tonic-gate bool_t
8867c478bd9Sstevel@tonic-gate db_table::cacheValid(entryp loc) {
8877c478bd9Sstevel@tonic-gate 	bool_t		ret;
8887c478bd9Sstevel@tonic-gate 	struct timeval	now;
8897c478bd9Sstevel@tonic-gate 
8907c478bd9Sstevel@tonic-gate 	(void) gettimeofday(&now, 0);
8917c478bd9Sstevel@tonic-gate 
8927c478bd9Sstevel@tonic-gate 	READLOCK(this, FALSE, "db_table::cacheValid r");
8937c478bd9Sstevel@tonic-gate 
8947c478bd9Sstevel@tonic-gate 	if (loc < 0 || loc >= table_size || tab == 0 || tab[loc] == 0)
8957c478bd9Sstevel@tonic-gate 		ret = FALSE;
8967c478bd9Sstevel@tonic-gate 	else if (mapping.expire == 0 || mapping.expire[loc] >= now.tv_sec)
8977c478bd9Sstevel@tonic-gate 		ret = TRUE;
8987c478bd9Sstevel@tonic-gate 	else
8997c478bd9Sstevel@tonic-gate 		ret = FALSE;
9007c478bd9Sstevel@tonic-gate 
9017c478bd9Sstevel@tonic-gate 	READUNLOCK(this, ret, "db_table::cacheValid ru");
9027c478bd9Sstevel@tonic-gate 
9037c478bd9Sstevel@tonic-gate 	return (ret);
9047c478bd9Sstevel@tonic-gate }
9057c478bd9Sstevel@tonic-gate 
9067c478bd9Sstevel@tonic-gate /*
9077c478bd9Sstevel@tonic-gate  * If the supplied object has the same content as the one at 'loc',
9087c478bd9Sstevel@tonic-gate  * update the expiration time for the latter, and return TRUE.
9097c478bd9Sstevel@tonic-gate  */
9107c478bd9Sstevel@tonic-gate bool_t
9117c478bd9Sstevel@tonic-gate db_table::dupEntry(entry_object *obj, entryp loc) {
9127c478bd9Sstevel@tonic-gate 	if (obj == 0 || loc < 0 || loc >= table_size || tab == 0 ||
9137c478bd9Sstevel@tonic-gate 			tab[loc] == 0)
9147c478bd9Sstevel@tonic-gate 		return (FALSE);
9157c478bd9Sstevel@tonic-gate 
9167c478bd9Sstevel@tonic-gate 	if (sameEntry(obj, tab[loc])) {
9177c478bd9Sstevel@tonic-gate 		setEntryExp(loc, tab[loc], 0);
9187c478bd9Sstevel@tonic-gate 
9197c478bd9Sstevel@tonic-gate 		if (enumMode.flag > 0)
9207c478bd9Sstevel@tonic-gate 			enumTouch(loc);
9217c478bd9Sstevel@tonic-gate 		return (TRUE);
9227c478bd9Sstevel@tonic-gate 	}
9237c478bd9Sstevel@tonic-gate 
9247c478bd9Sstevel@tonic-gate 	return (FALSE);
9257c478bd9Sstevel@tonic-gate }
9267c478bd9Sstevel@tonic-gate 
9277c478bd9Sstevel@tonic-gate /*
9287c478bd9Sstevel@tonic-gate  * If enumeration mode is enabled, we keep a shadow array that initially
9297c478bd9Sstevel@tonic-gate  * starts out the same as 'tab'. Any update activity (add, remove, replace,
9307c478bd9Sstevel@tonic-gate  * or update timestamp) for an entry in the table means we delete the shadow
9317c478bd9Sstevel@tonic-gate  * array pointer. When ending enumeration mode, we return the shadow array.
9327c478bd9Sstevel@tonic-gate  * Any non-NULL entries in the array have not been updated since the start
9337c478bd9Sstevel@tonic-gate  * of the enum mode.
9347c478bd9Sstevel@tonic-gate  *
9357c478bd9Sstevel@tonic-gate  * The indended use is for enumeration of an LDAP container, where we
9367c478bd9Sstevel@tonic-gate  * will update all entries that currently exist in LDAP. The entries we
9377c478bd9Sstevel@tonic-gate  * don't update are those that don't exist in LDAP, and thus should be
9387c478bd9Sstevel@tonic-gate  * removed.
9397c478bd9Sstevel@tonic-gate  *
9407c478bd9Sstevel@tonic-gate  * Note that any LDAP query strictly speaking can be a partial enumeration
9417c478bd9Sstevel@tonic-gate  * (i.e., return more than one match). Since the query might also have
9427c478bd9Sstevel@tonic-gate  * matched multiple local DB entries, we need to do the same work as for
9437c478bd9Sstevel@tonic-gate  * enumeration for any query. In order to avoid having to work on the
9447c478bd9Sstevel@tonic-gate  * whole 'tab' array for simple queries (which we expect usually will
9457c478bd9Sstevel@tonic-gate  * match just one or at most a few entries), we have a "reduced" enum mode,
9467c478bd9Sstevel@tonic-gate  * where the caller supplies a count of the number of DB entries (derived
9477c478bd9Sstevel@tonic-gate  * from db_mindex::satisfy_query() or similar), and then uses enumSetup()
9487c478bd9Sstevel@tonic-gate  * to specify which 'tab' entries we're interested in.
9497c478bd9Sstevel@tonic-gate  */
9507c478bd9Sstevel@tonic-gate void
9517c478bd9Sstevel@tonic-gate db_table::setEnumMode(long enumNum) {
952*8d0852b7SRichard Lowe 	const char	*myself = "setEnumMode";
9537c478bd9Sstevel@tonic-gate 
9547c478bd9Sstevel@tonic-gate 	enumMode.flag++;
9557c478bd9Sstevel@tonic-gate 	if (enumMode.flag == 1) {
9567c478bd9Sstevel@tonic-gate 		db_status	stat;
9577c478bd9Sstevel@tonic-gate 
9587c478bd9Sstevel@tonic-gate 		if (enumNum < 0)
9597c478bd9Sstevel@tonic-gate 			enumNum = 0;
9607c478bd9Sstevel@tonic-gate 		else if (enumNum >= table_size)
9617c478bd9Sstevel@tonic-gate 			enumNum = table_size;
9627c478bd9Sstevel@tonic-gate 
9637c478bd9Sstevel@tonic-gate 		enumCount.flag = enumNum;
9647c478bd9Sstevel@tonic-gate 
9657c478bd9Sstevel@tonic-gate 		stat = allocateEnumArray(0, table_size);
9667c478bd9Sstevel@tonic-gate 
9677c478bd9Sstevel@tonic-gate 		if (stat != DB_SUCCESS) {
9687c478bd9Sstevel@tonic-gate 			enumMode.flag = 0;
9697c478bd9Sstevel@tonic-gate 			enumCount.flag = 0;
9707c478bd9Sstevel@tonic-gate 			logmsg(MSG_NOTIMECHECK, LOG_ERR,
9717c478bd9Sstevel@tonic-gate 		"%s: No memory for enum check array; entry removal disabled",
9727c478bd9Sstevel@tonic-gate 				myself);
9737c478bd9Sstevel@tonic-gate 		}
9747c478bd9Sstevel@tonic-gate 	}
9757c478bd9Sstevel@tonic-gate }
9767c478bd9Sstevel@tonic-gate 
9777c478bd9Sstevel@tonic-gate void
9787c478bd9Sstevel@tonic-gate db_table::clearEnumMode(void) {
9797c478bd9Sstevel@tonic-gate 	if (enumMode.flag > 0) {
9807c478bd9Sstevel@tonic-gate 		enumMode.flag--;
9817c478bd9Sstevel@tonic-gate 		if (enumMode.flag == 0) {
9827c478bd9Sstevel@tonic-gate 			sfree(enumArray.ptr);
9837c478bd9Sstevel@tonic-gate 			enumArray.ptr = 0;
9847c478bd9Sstevel@tonic-gate 			if (enumCount.flag > 0) {
9857c478bd9Sstevel@tonic-gate 				sfree(enumIndex.ptr);
9867c478bd9Sstevel@tonic-gate 				enumIndex.ptr = 0;
9877c478bd9Sstevel@tonic-gate 				enumCount.flag = 0;
9887c478bd9Sstevel@tonic-gate 			}
9897c478bd9Sstevel@tonic-gate 		}
9907c478bd9Sstevel@tonic-gate 	}
9917c478bd9Sstevel@tonic-gate }
9927c478bd9Sstevel@tonic-gate 
9937c478bd9Sstevel@tonic-gate entry_object **
9947c478bd9Sstevel@tonic-gate db_table::endEnumMode(long *numEa) {
9957c478bd9Sstevel@tonic-gate 	if (enumMode.flag > 0) {
9967c478bd9Sstevel@tonic-gate 		enumMode.flag--;
9977c478bd9Sstevel@tonic-gate 		if (enumMode.flag == 0) {
9987c478bd9Sstevel@tonic-gate 			entry_obj	**ea = (entry_object **)enumArray.ptr;
9997c478bd9Sstevel@tonic-gate 			long		nea;
10007c478bd9Sstevel@tonic-gate 
10017c478bd9Sstevel@tonic-gate 			enumArray.ptr = 0;
10027c478bd9Sstevel@tonic-gate 
10037c478bd9Sstevel@tonic-gate 			if (enumCount.flag > 0) {
10047c478bd9Sstevel@tonic-gate 				nea = enumCount.flag;
10057c478bd9Sstevel@tonic-gate 				enumCount.flag = 0;
10067c478bd9Sstevel@tonic-gate 				sfree(enumIndex.ptr);
10077c478bd9Sstevel@tonic-gate 				enumIndex.ptr = 0;
10087c478bd9Sstevel@tonic-gate 			} else {
10097c478bd9Sstevel@tonic-gate 				nea = table_size;
10107c478bd9Sstevel@tonic-gate 			}
10117c478bd9Sstevel@tonic-gate 
10127c478bd9Sstevel@tonic-gate 			if (numEa != 0)
10137c478bd9Sstevel@tonic-gate 				*numEa = nea;
10147c478bd9Sstevel@tonic-gate 
10157c478bd9Sstevel@tonic-gate 			return (ea);
10167c478bd9Sstevel@tonic-gate 		}
10177c478bd9Sstevel@tonic-gate 	}
10187c478bd9Sstevel@tonic-gate 
10197c478bd9Sstevel@tonic-gate 	if (numEa != 0)
10207c478bd9Sstevel@tonic-gate 		*numEa = 0;
10217c478bd9Sstevel@tonic-gate 
10227c478bd9Sstevel@tonic-gate 	return (0);
10237c478bd9Sstevel@tonic-gate }
10247c478bd9Sstevel@tonic-gate 
10257c478bd9Sstevel@tonic-gate /*
10267c478bd9Sstevel@tonic-gate  * Set the appropriate entry in the enum array to NULL.
10277c478bd9Sstevel@tonic-gate  */
10287c478bd9Sstevel@tonic-gate void
10297c478bd9Sstevel@tonic-gate db_table::enumTouch(entryp loc) {
10307c478bd9Sstevel@tonic-gate 	if (loc < 0 || loc >= table_size)
10317c478bd9Sstevel@tonic-gate 		return;
10327c478bd9Sstevel@tonic-gate 
10337c478bd9Sstevel@tonic-gate 	if (enumMode.flag > 0) {
10347c478bd9Sstevel@tonic-gate 		if (enumCount.flag < 1) {
10357c478bd9Sstevel@tonic-gate 			((entry_object **)enumArray.ptr)[loc] = 0;
10367c478bd9Sstevel@tonic-gate 		} else {
10377c478bd9Sstevel@tonic-gate 			int	i;
10387c478bd9Sstevel@tonic-gate 
10397c478bd9Sstevel@tonic-gate 			for (i = 0; i < enumCount.flag; i++) {
10407c478bd9Sstevel@tonic-gate 				if (loc == ((entryp *)enumIndex.ptr)[i]) {
10417c478bd9Sstevel@tonic-gate 					((entry_object **)enumArray.ptr)[i] = 0;
10427c478bd9Sstevel@tonic-gate 					break;
10437c478bd9Sstevel@tonic-gate 				}
10447c478bd9Sstevel@tonic-gate 			}
10457c478bd9Sstevel@tonic-gate 		}
10467c478bd9Sstevel@tonic-gate 	}
10477c478bd9Sstevel@tonic-gate }
10487c478bd9Sstevel@tonic-gate 
10497c478bd9Sstevel@tonic-gate /*
10507c478bd9Sstevel@tonic-gate  * Add the entry indicated by 'loc' to the enumIndex array, at 'index'.
10517c478bd9Sstevel@tonic-gate  */
10527c478bd9Sstevel@tonic-gate void
10537c478bd9Sstevel@tonic-gate db_table::enumSetup(entryp loc, long index) {
10547c478bd9Sstevel@tonic-gate 	if (enumMode.flag == 0 || loc < 0 || loc >= table_size ||
10557c478bd9Sstevel@tonic-gate 			index < 0 || index >= enumCount.flag)
10567c478bd9Sstevel@tonic-gate 		return;
10577c478bd9Sstevel@tonic-gate 
10587c478bd9Sstevel@tonic-gate 	((entryp *)enumIndex.ptr)[index] = loc;
10597c478bd9Sstevel@tonic-gate 	((entry_object **)enumArray.ptr)[index] = tab[loc];
10607c478bd9Sstevel@tonic-gate }
10617c478bd9Sstevel@tonic-gate 
10627c478bd9Sstevel@tonic-gate /*
10637c478bd9Sstevel@tonic-gate  * Touch, i.e., update the expiration time for the entry. Also, if enum
10647c478bd9Sstevel@tonic-gate  * mode is in effect, mark the entry used for enum purposes.
10657c478bd9Sstevel@tonic-gate  */
10667c478bd9Sstevel@tonic-gate void
10677c478bd9Sstevel@tonic-gate db_table::touchEntry(entryp loc) {
10687c478bd9Sstevel@tonic-gate 	if (loc < 0 || loc >= table_size || tab == 0 || tab[loc] == 0)
10697c478bd9Sstevel@tonic-gate 		return;
10707c478bd9Sstevel@tonic-gate 
10717c478bd9Sstevel@tonic-gate 	setEntryExp(loc, tab[loc], 0);
10727c478bd9Sstevel@tonic-gate 
10737c478bd9Sstevel@tonic-gate 	enumTouch(loc);
10747c478bd9Sstevel@tonic-gate }
10757c478bd9Sstevel@tonic-gate 
10767c478bd9Sstevel@tonic-gate /* ************************* pickle_table ********************* */
10777c478bd9Sstevel@tonic-gate /* Does the actual writing to/from file specific for db_table structure. */
10787c478bd9Sstevel@tonic-gate /*
10797c478bd9Sstevel@tonic-gate  * This was a static earlier with the func name being transfer_aux. The
10807c478bd9Sstevel@tonic-gate  * backup and restore project needed this to copy files over.
10817c478bd9Sstevel@tonic-gate  */
10827c478bd9Sstevel@tonic-gate bool_t
10837c478bd9Sstevel@tonic-gate transfer_aux_table(XDR* x, pptr dp)
10847c478bd9Sstevel@tonic-gate {
10857c478bd9Sstevel@tonic-gate 	return (xdr_db_table(x, (db_table*) dp));
10867c478bd9Sstevel@tonic-gate }
10877c478bd9Sstevel@tonic-gate 
10887c478bd9Sstevel@tonic-gate class pickle_table: public pickle_file {
10897c478bd9Sstevel@tonic-gate     public:
10907c478bd9Sstevel@tonic-gate 	pickle_table(char *f, pickle_mode m) : pickle_file(f, m) {}
10917c478bd9Sstevel@tonic-gate 
10927c478bd9Sstevel@tonic-gate 	/* Transfers db_table structure pointed to by dp to/from file. */
10937c478bd9Sstevel@tonic-gate 	int transfer(db_table* dp)
10947c478bd9Sstevel@tonic-gate 	{ return (pickle_file::transfer((pptr) dp, &transfer_aux_table)); }
10957c478bd9Sstevel@tonic-gate };
10967c478bd9Sstevel@tonic-gate 
10977c478bd9Sstevel@tonic-gate /*
10987c478bd9Sstevel@tonic-gate  * Writes the contents of table, including the all the entries, into the
10997c478bd9Sstevel@tonic-gate  * specified file in XDR format.  May need to change this to use APPEND
11007c478bd9Sstevel@tonic-gate  * mode instead.
11017c478bd9Sstevel@tonic-gate  */
11027c478bd9Sstevel@tonic-gate int
11037c478bd9Sstevel@tonic-gate db_table::dump(char *file)
11047c478bd9Sstevel@tonic-gate {
11057c478bd9Sstevel@tonic-gate 	int	ret;
11067c478bd9Sstevel@tonic-gate 	READLOCK(this, -1, "r db_table::dump");
11077c478bd9Sstevel@tonic-gate 	pickle_table f(file, PICKLE_WRITE);   /* may need to use APPEND mode */
11087c478bd9Sstevel@tonic-gate 	int status = f.transfer(this);
11097c478bd9Sstevel@tonic-gate 
11107c478bd9Sstevel@tonic-gate 	if (status == 1)
11117c478bd9Sstevel@tonic-gate 		ret = -1;
11127c478bd9Sstevel@tonic-gate 	else
11137c478bd9Sstevel@tonic-gate 		ret = status;
11147c478bd9Sstevel@tonic-gate 	READUNLOCK(this, ret, "ru db_table::dump");
11157c478bd9Sstevel@tonic-gate }
11167c478bd9Sstevel@tonic-gate 
11177c478bd9Sstevel@tonic-gate /* Constructor that loads in the table from the given file */
11187c478bd9Sstevel@tonic-gate db_table::db_table(char *file)  : freelist()
11197c478bd9Sstevel@tonic-gate {
11207c478bd9Sstevel@tonic-gate 	pickle_table f(file, PICKLE_READ);
11217c478bd9Sstevel@tonic-gate 	tab = NULL;
11227c478bd9Sstevel@tonic-gate 	table_size = last_used = count = 0;
11237c478bd9Sstevel@tonic-gate 
11247c478bd9Sstevel@tonic-gate 	/* load  table */
11257c478bd9Sstevel@tonic-gate 	if (f.transfer(this) < 0) {
11267c478bd9Sstevel@tonic-gate 		/* fell through, something went wrong, initialize to null */
11277c478bd9Sstevel@tonic-gate 		tab = NULL;
11287c478bd9Sstevel@tonic-gate 		table_size = last_used = count = 0;
11297c478bd9Sstevel@tonic-gate 		freelist.init();
11307c478bd9Sstevel@tonic-gate 	}
11317c478bd9Sstevel@tonic-gate 
11327c478bd9Sstevel@tonic-gate 	db_table_ldap_init();
11337c478bd9Sstevel@tonic-gate 	initMappingStruct(&mapping);
11347c478bd9Sstevel@tonic-gate }
11357c478bd9Sstevel@tonic-gate 
11367c478bd9Sstevel@tonic-gate /* Returns whether location is valid. */
11377c478bd9Sstevel@tonic-gate bool_t db_table::entry_exists_p(entryp i) {
11387c478bd9Sstevel@tonic-gate 	bool_t	ret = FALSE;
11397c478bd9Sstevel@tonic-gate 	READLOCK(this, FALSE, "r db_table::entry_exists_p");
11407c478bd9Sstevel@tonic-gate 	if (tab != NULL && i < table_size)
11417c478bd9Sstevel@tonic-gate 		ret = tab[i] != NULL;
11427c478bd9Sstevel@tonic-gate 	READUNLOCK(this, ret, "ru db_table::entry_exists_p");
11437c478bd9Sstevel@tonic-gate 	return (ret);
11447c478bd9Sstevel@tonic-gate }
11457c478bd9Sstevel@tonic-gate 
11467c478bd9Sstevel@tonic-gate /* Empty free list */
11477c478bd9Sstevel@tonic-gate void db_free_list::init() {
11487c478bd9Sstevel@tonic-gate 	WRITELOCKV(this, "w db_free_list::init");
11497c478bd9Sstevel@tonic-gate 	head = NULL;
11507c478bd9Sstevel@tonic-gate 	count = 0;
11517c478bd9Sstevel@tonic-gate 	WRITEUNLOCKV(this, "wu db_free_list::init");
11527c478bd9Sstevel@tonic-gate }
1153