/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License, Version 1.0 only

 * (the "License").  You may not use this file except in compliance

 * with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/

/*	  All Rights Reserved  	*/

/*

 * University Copyright- Copyright (c) 1982, 1986, 1988

 * The Regents of the University of California

 * All Rights Reserved

 *

 * University Acknowledgment- Portions of this document are derived from

 * software developed by the University of California, Berkeley, and its

 * contributors.

 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include "synonyms.h"

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <sys/file.h>

#include <stdio.h>

#include <stdlib.h>

#include <errno.h>

#include <ndbm.h>

#include <unistd.h>

#include <string.h>

/* add support for batched writing for NIS */

#define	_DBM_DEFWRITE 0x4

#define	_DBM_DIRTY 0x8

#define	_DBM_DIRDIRTY 0x10

#define	dbm_dirty(db) ((db)->dbm_flags & _DBM_DIRTY)

#define	dbm_dirdirty(db) ((db)->dbm_flags & _DBM_DIRDIRTY)

#define	dbm_defwrite(db) ((db)->dbm_flags & _DBM_DEFWRITE)

#define	dbm_setdirty(db) (db)->dbm_flags |= _DBM_DIRTY

#define	dbm_clrdirty(db) (db)->dbm_flags &= ~_DBM_DIRTY

#define	dbm_setdirdirty(db) (db)->dbm_flags |= _DBM_DIRDIRTY

#define	dbm_clrdirdirty(db) (db)->dbm_flags &= ~_DBM_DIRDIRTY

/*

 * forward declarations

 */

static datum makdatum(char *, int);

static unsigned long dcalchash(datum);

static void dbm_access(DBM *, unsigned long);

static int finddatum(char *, datum);

static int delitem(char *, int);

static int additem(char *, datum, datum);

static int cmpdatum(datum, datum);

static int setbit(DBM *);

static int getbit(DBM *);

static int dbm_flushdir(DBM *);

static int dbm_flushpag(DBM *db);

/* the following three are required by mapfile-vers */

datum dbm_do_nextkey(DBM *, datum);

int dbm_close_status(DBM *);

/* used to make a dbm file all at once instead of incrementally */

void

dbm_setdefwrite(DBM *db)

{

	db->dbm_flags |= _DBM_DEFWRITE;

}

#undef	dbm_error

int

dbm_error(DBM *db)

{

	return (db->dbm_flags & _DBM_IOERR);

}

#undef	dbm_clearerr

int

dbm_clearerr(DBM *db)

{

	return (db->dbm_flags &= ~_DBM_IOERR);

}

int

dbm_flush(DBM *db)

{

	int ok = 0;

	if (dbm_flushpag(db) < 0)

		ok = -1;

	if (dbm_flushdir(db) < 0)

		ok = -1;

	return (ok);

}

static int

dbm_flushpag(DBM *db)

{

	int ok = 0;

	off64_t where;

	if (dbm_dirty(db)) { /* must page out the page */

		where = (((off64_t)db->dbm_pagbno) * PBLKSIZ);

		if ((lseek64(db->dbm_pagf, where, L_SET) != where) ||

		    (write(db->dbm_pagf, db->dbm_pagbuf, PBLKSIZ) != PBLKSIZ)) {

			db->dbm_flags |= _DBM_IOERR;

			ok = -1;

		}

		dbm_clrdirty(db);

	}

	return (ok);

}

static int

dbm_flushdir(DBM *db)

{

	int ok = 0;

	off64_t where;

	if (dbm_dirdirty(db)) { /* must page out the dir */

		where = (((off64_t)db->dbm_dirbno) * DBLKSIZ);

		if ((lseek64(db->dbm_dirf, where, L_SET) != where) ||

		    (write(db->dbm_dirf, db->dbm_dirbuf, DBLKSIZ) != DBLKSIZ)) {

			ok = -1;

		}

		dbm_clrdirdirty(db);

	}

	return (ok);

}

#define	BYTESIZ 8

#undef setbit

DBM *

dbm_open(const char *file, int flags, mode_t mode)

{

	struct stat64 statb;

	DBM *db;

	int	serrno;

	if ((db = (DBM *)malloc(sizeof (*db))) == 0) {

		errno = ENOMEM;

		return ((DBM *)0);

	}

	db->dbm_flags = (flags & 03) == O_RDONLY ? _DBM_RDONLY : 0;

	if ((flags & 03) == O_WRONLY)

		flags = (flags & ~03) | O_RDWR;

	if (strlcpy(db->dbm_pagbuf, file, sizeof (db->dbm_pagbuf)) >=

	    sizeof (db->dbm_pagbuf) ||

	    strlcat(db->dbm_pagbuf, ".pag", sizeof (db->dbm_pagbuf)) >=

	    sizeof (db->dbm_pagbuf)) {

		/*

		 * file.pag does not fit into dbm_pagbuf.

		 * fail with ENAMETOOLONG.

		 */

		serrno = ENAMETOOLONG;

		goto bad;

	}

	db->dbm_pagf = open64(db->dbm_pagbuf, flags, mode);

	if (db->dbm_pagf < 0) {

		serrno = errno;

		goto bad;

	}

	/*

	 * We know this won't overflow so it is safe to ignore the

	 * return value; we use strl* to prevent false hits in

	 * code sweeps.

	 */

	(void) strlcpy(db->dbm_pagbuf, file, sizeof (db->dbm_pagbuf));

	(void) strlcat(db->dbm_pagbuf, ".dir", sizeof (db->dbm_pagbuf));

	db->dbm_dirf = open64(db->dbm_pagbuf, flags, mode);

	if (db->dbm_dirf < 0) {

		serrno = errno;

		goto bad1;

	}

	(void) fstat64(db->dbm_dirf, &statb);

	db->dbm_maxbno = statb.st_size * BYTESIZ-1;

	db->dbm_pagbno = db->dbm_dirbno = -1;

	return (db);

bad1:

	(void) close(db->dbm_pagf);

bad:

	free((char *)db);

	errno = serrno;

	return ((DBM *)0);

}

void

dbm_close(DBM *db)

{

(void) dbm_close_status(db);

}

/* close with return code */

int

dbm_close_status(DBM *db)

{

	int ok;

	ok = 0;

	if (dbm_flush(db) < 0)

		ok = -1;

	if (close(db->dbm_dirf) < 0)

		ok = -1;

	if (close(db->dbm_pagf) < 0)

		ok = -1;

	free((char *)db);

	return (ok);

}

long

dbm_forder(DBM *db, datum key)

{

	unsigned long hash;

	hash = dcalchash(key);

	for (db->dbm_hmask = 0; ; db->dbm_hmask = (db->dbm_hmask<<1)+1) {

		db->dbm_blkno = hash & db->dbm_hmask;

		db->dbm_bitno = db->dbm_blkno + db->dbm_hmask;

		if (getbit(db) == 0)

			break;

	}

	return (db->dbm_blkno);

}

datum

dbm_fetch(DBM *db, datum key)

{

	int i;

	datum item;

	if (dbm_error(db))

		goto err;

	dbm_access(db, dcalchash(key));

	if ((i = finddatum(db->dbm_pagbuf, key)) >= 0) {

		item = makdatum(db->dbm_pagbuf, i+1);

		if (item.dptr != NULL)

			return (item);

	}

err:

	item.dptr = NULL;

	item.dsize = 0;

	return (item);

}

int

dbm_delete(DBM *db, datum key)

{

	int i;

	off64_t where;

	if (dbm_error(db))

		return (-1);

	if (dbm_rdonly(db)) {

		errno = EPERM;

		return (-1);

	}

	dbm_access(db, dcalchash(key));

	if ((i = finddatum(db->dbm_pagbuf, key)) < 0)

		return (-1);

	if (!delitem(db->dbm_pagbuf, i))

		goto err;

	db->dbm_pagbno = db->dbm_blkno;

	if (dbm_defwrite(db)) {

		dbm_setdirty(db);

	} else {

		where = (((off64_t)db->dbm_blkno) * PBLKSIZ);

		if ((lseek64(db->dbm_pagf, where, L_SET) != where) ||

		    (write(db->dbm_pagf, db->dbm_pagbuf, PBLKSIZ) != PBLKSIZ)) {

			err:

				db->dbm_flags |= _DBM_IOERR;

				return (-1);

		}

	}

	return (0);

}

int

dbm_store(DBM *db, datum key, datum dat, int replace)

{

	int i;

	datum item, item1;

	char ovfbuf[PBLKSIZ];

	unsigned long hashdiff, key_hash, item_hash;

	off64_t where;

	if (dbm_error(db))

		return (-1);

	if (dbm_rdonly(db)) {

		errno = EPERM;

		return (-1);

	}

loop:

	key_hash = dcalchash(key);

	dbm_access(db, key_hash);

	if ((i = finddatum(db->dbm_pagbuf, key)) >= 0) {

		if (!replace)

			return (1);

		if (!delitem(db->dbm_pagbuf, i)) {

			db->dbm_flags |= _DBM_IOERR;

			return (-1);

		}

	}

	if (!additem(db->dbm_pagbuf, key, dat))

		goto split;

	db->dbm_pagbno = db->dbm_blkno;

	if (dbm_defwrite(db)) {

		dbm_setdirty(db);

	} else {

		where = (((off64_t)db->dbm_blkno) * PBLKSIZ);

		if ((lseek64(db->dbm_pagf, where, L_SET) != where) ||

		    (write(db->dbm_pagf, db->dbm_pagbuf, PBLKSIZ) != PBLKSIZ)) {

			db->dbm_flags |= _DBM_IOERR;

			return (-1);

		}

	}

	return (0);

split:

	hashdiff = 0;

	if (key.dsize + dat.dsize + 3 * (int)sizeof (short) >= PBLKSIZ) {

		db->dbm_flags |= _DBM_IOERR;

		errno = ENOSPC;

		return (-1);

	}

	(void) memset(ovfbuf, 0, PBLKSIZ);

	for (i = 0; ; ) {

		item = makdatum(db->dbm_pagbuf, i);

		if (item.dptr == NULL)

			break;

		item_hash = dcalchash(item);

		if (item_hash != key_hash) {

			hashdiff++;

		}

		if (item_hash & (db->dbm_hmask+1)) {

			item1 = makdatum(db->dbm_pagbuf, i+1);

			if (item1.dptr == NULL) {

				/* (void) fprintf(stderr, "ndbm: */

				/* split not paired\n"); */

				db->dbm_flags |= _DBM_IOERR;

				break;

			}

			if (!additem(ovfbuf, item, item1) ||

			    !delitem(db->dbm_pagbuf, i)) {

				db->dbm_flags |= _DBM_IOERR;

				return (-1);

			}

			continue;

		}

		i += 2;

	}

	db->dbm_pagbno = db->dbm_blkno;

	where = (((off64_t)db->dbm_blkno) * PBLKSIZ);

	if ((lseek64(db->dbm_pagf, where, L_SET) != where) ||

	    (write(db->dbm_pagf, db->dbm_pagbuf, PBLKSIZ) != PBLKSIZ)) {

		db->dbm_flags |= _DBM_IOERR;

		return (-1);

	}

	dbm_clrdirty(db); /* clear dirty */

	where = (((off64_t)db->dbm_blkno + db->dbm_hmask + 1) * PBLKSIZ);

	if ((lseek64(db->dbm_pagf, where, L_SET) != where) ||

	    (write(db->dbm_pagf, ovfbuf, PBLKSIZ) != PBLKSIZ)) {

		db->dbm_flags |= _DBM_IOERR;

		return (-1);

	}

	if (setbit(db) < 0) {

		db->dbm_flags |= _DBM_IOERR;

		return (-1);

	}

	if (hashdiff == 0) {

		db->dbm_flags |= _DBM_IOERR;

		return (-1);

	}

	goto loop;

}

static unsigned long

dbm_hashinc(DBM *db, unsigned long hash)

{

	long bit;

	hash &= db->dbm_hmask;

	bit = db->dbm_hmask+1;

	for (;;) {

		bit >>= 1;

		if (bit == 0)

			return (0L);

		if ((hash&bit) == 0)

			return (hash|bit);

		hash &= ~bit;

	}

}

static datum nullkey = {NULL, 0};

datum

dbm_firsthash(DBM *db, unsigned long hash)

{

	int i, j;

	datum item, bitem;

loop:

	dbm_access(db, hash);

	j = 0;

	bitem = makdatum(db->dbm_pagbuf, 0);

	for (i = 2; ; i += 2) {

		item = makdatum(db->dbm_pagbuf, i);

		if (item.dptr == NULL)

			break;

		if (cmpdatum(bitem, item) < 0) {

			j = i;

			bitem = item;

		}

	}

	if (bitem.dptr != NULL) {

		db->dbm_keyptr = j + 2;

		db->dbm_blkptr = db->dbm_blkno;

		return (bitem);

	}

	hash = dbm_hashinc(db, hash);

	if (hash == 0)

		return (item); /* null item */

	goto loop;

}

datum

dbm_firstkey(DBM *db)

{

	db->dbm_blkptr = 0L;

	db->dbm_keyptr = 0;

	return (dbm_firsthash(db, 0L));

}

datum

dbm_nextkey(DBM *db)

{

	return (dbm_do_nextkey(db, nullkey));

}

/*

 * this is used if keyptr-2, blocknum doesn't point to the previous

 * specific key allowing the fast hash order search --

 * its use indicates user tampering with our state variables,

 * which some evil users might do to search from some specific place.

 * It finds the first key at or after blkptr, keyptr in block seq order

 * this requires looking at all sorts of emtpy blocks in many cases

 */

static

datum

dbm_slow_nextkey(DBM *db)

{

	struct stat64 statb;

	datum item;

	off64_t where;

	if (dbm_error(db) || fstat64(db->dbm_pagf, &statb) < 0)

		goto err;

	statb.st_size /= PBLKSIZ;

	for (;;) {

		if (db->dbm_blkptr != db->dbm_pagbno) {

			if (dbm_dirty(db)) (void) dbm_flushpag(db);

			db->dbm_pagbno = db->dbm_blkptr;

			where = (((off64_t)db->dbm_blkptr) * PBLKSIZ);

			if ((lseek64(db->dbm_pagf, where, L_SET) != where) ||

			    (read(db->dbm_pagf, db->dbm_pagbuf, PBLKSIZ) !=

				PBLKSIZ))

				(void) memset(db->dbm_pagbuf, 0, PBLKSIZ);

#ifdef DEBUG

			else if (chkblk(db->dbm_pagbuf) < 0)

				db->dbm_flags |= _DBM_IOERR;

#endif

		}

		/* Am I an empty block? */

		if (((short *)(uintptr_t)db->dbm_pagbuf)[0] != 0) {

			item = makdatum(db->dbm_pagbuf, db->dbm_keyptr);

			if (item.dptr != NULL) {

				db->dbm_keyptr += 2;

				return (item);

			}

			db->dbm_keyptr = 0;

		}

		/* go to next sequential block */

		if (++db->dbm_blkptr >= statb.st_size)

			break;

	}

err:

	item.dptr = NULL;

	item.dsize = 0;

	return (item);

}

datum

dbm_do_nextkey(DBM *db, datum inkey)