db185.c

/*-
 * See the file LICENSE for redistribution information.
 *
 * Copyright (c) 1996-2005
 *      Sleepycat Software.  All rights reserved.
 *
 * $Id: db185.c,v 12.2 2005/10/06 14:36:51 bostic Exp $
 */

#include "db_config.h"

#ifndef lint
static const char copyright[] =
    "Copyright (c) 1996-2005\nSleepycat Software Inc.  All rights reserved.\n";
#endif

#ifndef NO_SYSTEM_INCLUDES
#include <sys/types.h>

#include <fcntl.h>
#include <string.h>
#endif

#include "db_int.h"
#include "db185_int.h"

static int      db185_close __P((DB185 *));
static int      db185_compare __P((DB *, const DBT *, const DBT *));
static int      db185_del __P((const DB185 *, const DBT185 *, u_int));
static int      db185_fd __P((const DB185 *));
static int      db185_get __P((const DB185 *, const DBT185 *, DBT185 *, u_int));
static u_int32_t
                db185_hash __P((DB *, const void *, u_int32_t));
static size_t   db185_prefix __P((DB *, const DBT *, const DBT *));
static int      db185_put __P((const DB185 *, DBT185 *, const DBT185 *, u_int));
static int      db185_seq __P((const DB185 *, DBT185 *, DBT185 *, u_int));
static int      db185_sync __P((const DB185 *, u_int));

/*
 * EXTERN: #ifdef _DB185_INT_H_
 * EXTERN: DB185 *__db185_open
 * EXTERN:     __P((const char *, int, int, DBTYPE, const void *));
 * EXTERN: #else
 * EXTERN: DB *__db185_open
 * EXTERN:     __P((const char *, int, int, DBTYPE, const void *));
 * EXTERN: #endif
 */
DB185 *
__db185_open(file, oflags, mode, type, openinfo)
        const char *file;
        int oflags, mode;
        DBTYPE type;
        const void *openinfo;
{
        const BTREEINFO *bi;
        const HASHINFO *hi;
        const RECNOINFO *ri;
        DB *dbp;
        DB185 *db185p;
        DB_FH *fhp;
        int ret;

        dbp = NULL;
        db185p = NULL;

        if ((ret = db_create(&dbp, NULL, 0)) != 0)
                goto err;

        if ((ret = __os_calloc(NULL, 1, sizeof(DB185), &db185p)) != 0)
                goto err;

        /*
         * !!!
         * The DBTYPE enum wasn't initialized in DB 185, so it's off-by-one
         * from DB 2.0.
         */
        switch (type) {
        case 0:                                 /* DB_BTREE */
                type = DB_BTREE;
                if ((bi = openinfo) != NULL) {
                        if (bi->flags & ~R_DUP)
                                goto einval;
                        if (bi->flags & R_DUP)
                                (void)dbp->set_flags(dbp, DB_DUP);
                        if (bi->cachesize != 0)
                                (void)dbp->set_cachesize
                                    (dbp, 0, bi->cachesize, 0);
                        if (bi->minkeypage != 0)
                                (void)dbp->set_bt_minkey(dbp, bi->minkeypage);
                        if (bi->psize != 0)
                                (void)dbp->set_pagesize(dbp, bi->psize);
                        if (bi->prefix != NULL) {
                                db185p->prefix = bi->prefix;
                                dbp->set_bt_prefix(dbp, db185_prefix);
                        }
                        if (bi->compare != NULL) {
                                db185p->compare = bi->compare;
                                dbp->set_bt_compare(dbp, db185_compare);
                        }
                        if (bi->lorder != 0)
                                dbp->set_lorder(dbp, bi->lorder);
                }
                break;
        case 1:                                 /* DB_HASH */
                type = DB_HASH;
                if ((hi = openinfo) != NULL) {
                        if (hi->bsize != 0)
                                (void)dbp->set_pagesize(dbp, hi->bsize);
                        if (hi->ffactor != 0)
                                (void)dbp->set_h_ffactor(dbp, hi->ffactor);
                        if (hi->nelem != 0)
                                (void)dbp->set_h_nelem(dbp, hi->nelem);
                        if (hi->cachesize != 0)
                                (void)dbp->set_cachesize
                                    (dbp, 0, hi->cachesize, 0);
                        if (hi->hash != NULL) {
                                db185p->hash = hi->hash;
                                (void)dbp->set_h_hash(dbp, db185_hash);
                        }
                        if (hi->lorder != 0)
                                dbp->set_lorder(dbp, hi->lorder);
                }

                break;
        case 2:                                 /* DB_RECNO */
                type = DB_RECNO;

                /* DB 1.85 did renumbering by default. */
                (void)dbp->set_flags(dbp, DB_RENUMBER);

                /*
                 * !!!
                 * The file name given to DB 1.85 recno is the name of the DB
                 * 2.0 backing file.  If the file doesn't exist, create it if
                 * the user has the O_CREAT flag set, DB 1.85 did it for you,
                 * and DB 2.0 doesn't.
                 *
                 * !!!
                 * Setting the file name to NULL specifies that we're creating
                 * a temporary backing file, in DB 2.X.  If we're opening the
                 * DB file read-only, change the flags to read-write, because
                 * temporary backing files cannot be opened read-only, and DB
                 * 2.X will return an error.  We are cheating here -- if the
                 * application does a put on the database, it will succeed --
                 * although that would be a stupid thing for the application
                 * to do.
                 *
                 * !!!
                 * Note, the file name in DB 1.85 was a const -- we don't do
                 * that in DB 2.0, so do that cast.
                 */
                if (file != NULL) {
                        if (oflags & O_CREAT && __os_exists(file, NULL) != 0)
                                if (__os_openhandle(NULL, file,
                                    oflags, mode, &fhp) == 0)
                                        (void)__os_closehandle(NULL, fhp);
                        (void)dbp->set_re_source(dbp, file);

                        if (O_RDONLY)
                                oflags &= ~O_RDONLY;
                        oflags |= O_RDWR;
                        file = NULL;
                }

                if ((ri = openinfo) != NULL) {
                        /*
                         * !!!
                         * We can't support the bfname field.
                         */
#define BFMSG \
        "Berkeley DB: DB 1.85's recno bfname field is not supported.\n"
                        if (ri->bfname != NULL) {
                                dbp->errx(dbp, "%s", BFMSG);
                                goto einval;
                        }

                        if (ri->flags & ~(R_FIXEDLEN | R_NOKEY | R_SNAPSHOT))
                                goto einval;
                        if (ri->flags & R_FIXEDLEN) {
                                if (ri->bval != 0)
                                        (void)dbp->set_re_pad(dbp, ri->bval);
                                if (ri->reclen != 0)
                                        (void)dbp->set_re_len(dbp, ri->reclen);
                        } else
                                if (ri->bval != 0)
                                        (void)dbp->set_re_delim(dbp, ri->bval);

                        /*
                         * !!!
                         * We ignore the R_NOKEY flag, but that's okay, it was
                         * only an optimization that was never implemented.
                         */
                        if (ri->flags & R_SNAPSHOT)
                                (void)dbp->set_flags(dbp, DB_SNAPSHOT);

                        if (ri->cachesize != 0)
                                (void)dbp->set_cachesize
                                    (dbp, 0, ri->cachesize, 0);
                        if (ri->psize != 0)
                                (void)dbp->set_pagesize(dbp, ri->psize);
                        if (ri->lorder != 0)
                                dbp->set_lorder(dbp, ri->lorder);
                }
                break;
        default:
                goto einval;
        }

        db185p->close = db185_close;
        db185p->del = db185_del;
        db185p->fd = db185_fd;
        db185p->get = db185_get;
        db185p->put = db185_put;
        db185p->seq = db185_seq;
        db185p->sync = db185_sync;

        /*
         * Store a reference so we can indirect from the DB 1.85 structure
         * to the underlying DB structure, and vice-versa.  This has to be
         * done BEFORE the DB::open method call because the hash callback
         * is exercised as part of hash database initialization.
         */
        db185p->dbp = dbp;
        dbp->api_internal = db185p;

        /* Open the database. */
        if ((ret = dbp->open(dbp, NULL,
            file, NULL, type, __db_oflags(oflags), mode)) != 0)
                goto err;

        /* Create the cursor used for sequential ops. */
        if ((ret = dbp->cursor(dbp, NULL, &((DB185 *)db185p)->dbc, 0)) != 0)
                goto err;

        return (db185p);

einval: ret = EINVAL;

err:    if (db185p != NULL)
                __os_free(NULL, db185p);
        if (dbp != NULL)
                (void)dbp->close(dbp, 0);

        __os_set_errno(ret);
        return (NULL);
}

static int
db185_close(db185p)
        DB185 *db185p;
{
        DB *dbp;
        int ret;

        dbp = db185p->dbp;

        ret = dbp->close(dbp, 0);

        __os_free(NULL, db185p);

        if (ret == 0)
                return (0);

        __os_set_errno(ret);
        return (-1);
}

static int
db185_del(db185p, key185, flags)
        const DB185 *db185p;
        const DBT185 *key185;
        u_int flags;
{
        DB *dbp;
        DBT key;
        int ret;

        dbp = db185p->dbp;

        memset(&key, 0, sizeof(key));
        key.data = key185->data;
        key.size = key185->size;

        if (flags & ~R_CURSOR)
                goto einval;
        if (flags & R_CURSOR)
                ret = db185p->dbc->c_del(db185p->dbc, 0);
        else
                ret = dbp->del(dbp, NULL, &key, 0);

        switch (ret) {
        case 0:
                return (0);
        case DB_NOTFOUND:
                return (1);
        }

        if (0) {
einval:         ret = EINVAL;
        }
        __os_set_errno(ret);
        return (-1);
}

static int
db185_fd(db185p)
        const DB185 *db185p;
{
        DB *dbp;
        int fd, ret;

        dbp = db185p->dbp;

        if ((ret = dbp->fd(dbp, &fd)) == 0)
                return (fd);

        __os_set_errno(ret);
        return (-1);
}

static int
db185_get(db185p, key185, data185, flags)
        const DB185 *db185p;
        const DBT185 *key185;
        DBT185 *data185;
        u_int flags;
{
        DB *dbp;
        DBT key, data;
        int ret;

        dbp = db185p->dbp;

        memset(&key, 0, sizeof(key));
        key.data = key185->data;
        key.size = key185->size;
        memset(&data, 0, sizeof(data));
        data.data = data185->data;
        data.size = data185->size;

        if (flags)
                goto einval;

        switch (ret = dbp->get(dbp, NULL, &key, &data, 0)) {
        case 0:
                data185->data = data.data;
                data185->size = data.size;
                return (0);
        case DB_NOTFOUND:
                return (1);
        }

        if (0) {
einval:         ret = EINVAL;
        }
        __os_set_errno(ret);
        return (-1);
}

static int
db185_put(db185p, key185, data185, flags)
        const DB185 *db185p;
        DBT185 *key185;
        const DBT185 *data185;
        u_int flags;
{
        DB *dbp;
        DBC *dbcp_put;
        DBT key, data;
        int ret, t_ret;

        dbp = db185p->dbp;

        memset(&key, 0, sizeof(key));
        key.data = key185->data;
        key.size = key185->size;
        memset(&data, 0, sizeof(data));
        data.data = data185->data;
        data.size = data185->size;

        switch (flags) {
        case 0:
                ret = dbp->put(dbp, NULL, &key, &data, 0);
                break;
        case R_CURSOR:
                ret = db185p->dbc->c_put(db185p->dbc, &key, &data, DB_CURRENT);
                break;
        case R_IAFTER:
        case R_IBEFORE:
                if (dbp->type != DB_RECNO)
                        goto einval;

                if ((ret = dbp->cursor(dbp, NULL, &dbcp_put, 0)) != 0)
                        break;
                if ((ret =
                    dbcp_put->c_get(dbcp_put, &key, &data, DB_SET)) == 0) {
                        memset(&data, 0, sizeof(data));
                        data.data = data185->data;
                        data.size = data185->size;
                        ret = dbcp_put->c_put(dbcp_put, &key, &data,
                            flags == R_IAFTER ? DB_AFTER : DB_BEFORE);
                }
                if ((t_ret = dbcp_put->c_close(dbcp_put)) != 0 && ret == 0)
                        ret = t_ret;
                break;
        case R_NOOVERWRITE:
                ret = dbp->put(dbp, NULL, &key, &data, DB_NOOVERWRITE);
                break;
        case R_SETCURSOR:
                if (dbp->type != DB_BTREE && dbp->type != DB_RECNO)
                        goto einval;

                if ((ret = dbp->put(dbp, NULL, &key, &data, 0)) != 0)
                        break;
                ret =
                    db185p->dbc->c_get(db185p->dbc, &key, &data, DB_SET_RANGE);
                break;
        default:
                goto einval;
        }

        switch (ret) {
        case 0:
                key185->data = key.data;
                key185->size = key.size;
                return (0);
        case DB_KEYEXIST:
                return (1);
        }

        if (0) {
einval:         ret = EINVAL;
        }
        __os_set_errno(ret);
        return (-1);
}

static int
db185_seq(db185p, key185, data185, flags)
        const DB185 *db185p;
        DBT185 *key185, *data185;
        u_int flags;
{
        DB *dbp;
        DBT key, data;
        int ret;

        dbp = db185p->dbp;

        memset(&key, 0, sizeof(key));
        key.data = key185->data;
        key.size = key185->size;
        memset(&data, 0, sizeof(data));
        data.data = data185->data;
        data.size = data185->size;

        switch (flags) {
        case R_CURSOR:
                flags = DB_SET_RANGE;
                break;
        case R_FIRST:
                flags = DB_FIRST;
                break;
        case R_LAST:
                if (dbp->type != DB_BTREE && dbp->type != DB_RECNO)
                        goto einval;
                flags = DB_LAST;
                break;
        case R_NEXT:
                flags = DB_NEXT;
                break;
        case R_PREV:
                if (dbp->type != DB_BTREE && dbp->type != DB_RECNO)
                        goto einval;
                flags = DB_PREV;
                break;
        default:
                goto einval;
        }
        switch (ret = db185p->dbc->c_get(db185p->dbc, &key, &data, flags)) {
        case 0:
                key185->data = key.data;
                key185->size = key.size;
                data185->data = data.data;
                data185->size = data.size;
                return (0);
        case DB_NOTFOUND:
                return (1);
        }

        if (0) {
einval:         ret = EINVAL;
        }
        __os_set_errno(ret);
        return (-1);
}

static int
db185_sync(db185p, flags)
        const DB185 *db185p;
        u_int flags;
{
        DB *dbp;
        int ret;

        dbp = db185p->dbp;

        switch (flags) {
        case 0:
                break;
        case R_RECNOSYNC:
                /*
                 * !!!
                 * We can't support the R_RECNOSYNC flag.
                 */
#define RSMSG \
        "Berkeley DB: DB 1.85's R_RECNOSYNC sync flag is not supported.\n"
                dbp->errx(dbp, "%s", RSMSG);
                /* FALLTHROUGH */
        default:
                goto einval;
        }

        if ((ret = dbp->sync(dbp, 0)) == 0)
                return (0);

        if (0) {
einval:         ret = EINVAL;
        }
        __os_set_errno(ret);
        return (-1);
}

/*
 * db185_compare --
 *      Cutout routine to call the user's Btree comparison function.
 */
static int
db185_compare(dbp, a, b)
        DB *dbp;
        const DBT *a, *b;
{
        DBT185 a185, b185;

        a185.data = a->data;
        a185.size = a->size;
        b185.data = b->data;
        b185.size = b->size;

        return (((DB185 *)dbp->api_internal)->compare(&a185, &b185));
}

/*
 * db185_prefix --
 *      Cutout routine to call the user's Btree prefix function.
 */
static size_t
db185_prefix(dbp, a, b)
        DB *dbp;
        const DBT *a, *b;
{
        DBT185 a185, b185;

        a185.data = a->data;
        a185.size = a->size;
        b185.data = b->data;
        b185.size = b->size;

        return (((DB185 *)dbp->api_internal)->prefix(&a185, &b185));
}

/*
 * db185_hash --
 *      Cutout routine to call the user's hash function.
 */
static u_int32_t
db185_hash(dbp, key, len)
        DB *dbp;
        const void *key;
        u_int32_t len;
{
        return (((DB185 *)dbp->api_internal)->hash(key, (size_t)len));
}

---