aboutsummaryrefslogtreecommitdiff
path: root/db2/db185
diff options
context:
space:
mode:
Diffstat (limited to 'db2/db185')
-rw-r--r--db2/db185/db185.c472
-rw-r--r--db2/db185/db185_int.h137
2 files changed, 609 insertions, 0 deletions
diff --git a/db2/db185/db185.c b/db2/db185/db185.c
new file mode 100644
index 0000000000..933f55c813
--- /dev/null
+++ b/db2/db185/db185.c
@@ -0,0 +1,472 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 1996, 1997
+ * Sleepycat Software. All rights reserved.
+ */
+
+#include "config.h"
+
+#ifndef lint
+static const char copyright[] =
+"@(#) Copyright (c) 1997\n\
+ Sleepycat Software Inc. All rights reserved.\n";
+static const char sccsid[] = "@(#)db185.c 8.13 (Sleepycat) 8/24/97";
+#endif
+
+#ifndef NO_SYSTEM_INCLUDES
+#include <sys/types.h>
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#endif
+
+#include "db_int.h"
+#include "db185_int.h"
+#include "common_ext.h"
+
+static int db185_close __P((DB185 *));
+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 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));
+
+DB185 *
+__dbopen(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_INFO dbinfo, *dbinfop;
+ int s_errno;
+
+ if ((db185p = (DB185 *)calloc(1, sizeof(DB185))) == NULL)
+ return (NULL);
+ dbinfop = NULL;
+ memset(&dbinfo, 0, sizeof(dbinfo));
+
+ /*
+ * !!!
+ * 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) {
+ dbinfop = &dbinfo;
+ if (bi->flags & ~R_DUP)
+ goto einval;
+ if (bi->flags & R_DUP)
+ dbinfop->flags |= DB_DUP;
+ dbinfop->db_cachesize = bi->cachesize;
+ dbinfop->bt_maxkey = bi->maxkeypage;
+ dbinfop->bt_minkey = bi->minkeypage;
+ dbinfop->db_pagesize = bi->psize;
+ /*
+ * !!!
+ * Comparisons and prefix calls work because the DBT
+ * structures in 1.85 and 2.0 have the same initial
+ * fields.
+ */
+ dbinfop->bt_compare = bi->compare;
+ dbinfop->bt_prefix = bi->prefix;
+ dbinfop->db_lorder = bi->lorder;
+ }
+ break;
+ case 1: /* DB_HASH */
+ type = DB_HASH;
+ if ((hi = openinfo) != NULL) {
+ dbinfop = &dbinfo;
+ dbinfop->db_pagesize = hi->bsize;
+ dbinfop->h_ffactor = hi->ffactor;
+ dbinfop->h_nelem = hi->nelem;
+ dbinfop->db_cachesize = hi->cachesize;
+ dbinfop->h_hash = hi->hash;
+ dbinfop->db_lorder = hi->lorder;
+ }
+
+ break;
+ case 2: /* DB_RECNO */
+ type = DB_RECNO;
+ dbinfop = &dbinfo;
+
+ /* DB 1.85 did renumbering by default. */
+ dbinfop->flags |= 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.
+ *
+ * !!!
+ * 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 && __db_exists(file, NULL) != 0)
+ (void)close(open(file, oflags, mode));
+ dbinfop->re_source = (char *)file;
+ file = NULL;
+ }
+
+ if ((ri = openinfo) != NULL) {
+ /*
+ * !!!
+ * We can't support the bfname field.
+ */
+#define BFMSG "DB: DB 1.85's recno bfname field is not supported.\n"
+ if (ri->bfname != NULL) {
+ (void)write(2, BFMSG, sizeof(BFMSG) - 1);
+ goto einval;
+ }
+
+ if (ri->flags & ~(R_FIXEDLEN | R_NOKEY | R_SNAPSHOT))
+ goto einval;
+ if (ri->flags & R_FIXEDLEN) {
+ dbinfop->flags |= DB_FIXEDLEN;
+ if (ri->bval != 0) {
+ dbinfop->flags |= DB_PAD;
+ dbinfop->re_pad = ri->bval;
+ }
+ } else
+ if (ri->bval != 0) {
+ dbinfop->flags |= DB_DELIMITER;
+ dbinfop->re_delim = 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)
+ dbinfop->flags |= DB_SNAPSHOT;
+
+ dbinfop->db_cachesize = ri->cachesize;
+ dbinfop->db_pagesize = ri->psize;
+ dbinfop->db_lorder = ri->lorder;
+ dbinfop->re_len = ri->reclen;
+ }
+ 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 the returned pointer to the real DB 2.0 structure in the
+ * internal pointer. Ugly, but we're not going for pretty, here.
+ */
+ if ((errno = db_open(file,
+ type, __db_oflags(oflags), mode, NULL, dbinfop, &dbp)) != 0) {
+ free(db185p);
+ return (NULL);
+ }
+
+ /* Create the cursor used for sequential ops. */
+ if ((errno = dbp->cursor(dbp, NULL, &((DB185 *)db185p)->dbc)) != 0) {
+ s_errno = errno;
+ (void)dbp->close(dbp, 0);
+ free(db185p);
+ errno = s_errno;
+ return (NULL);
+ }
+
+ db185p->internal = dbp;
+ return (db185p);
+
+einval: free(db185p);
+ errno = EINVAL;
+ return (NULL);
+}
+weak_alias (__dbopen, dbopen)
+
+static int
+db185_close(db185p)
+ DB185 *db185p;
+{
+ DB *dbp;
+
+ dbp = (DB *)db185p->internal;
+
+ errno = dbp->close(dbp, 0);
+
+ free(db185p);
+
+ return (errno == 0 ? 0 : -1);
+}
+
+static int
+db185_del(db185p, key185, flags)
+ const DB185 *db185p;
+ const DBT185 *key185;
+ u_int flags;
+{
+ DB *dbp;
+ DBT key;
+
+ dbp = (DB *)db185p->internal;
+
+ memset(&key, 0, sizeof(key));
+ key.data = key185->data;
+ key.size = key185->size;
+
+ if (flags & ~R_CURSOR)
+ goto einval;
+ if (flags & R_CURSOR)
+ errno = db185p->dbc->c_del(db185p->dbc, 0);
+ else
+ errno = dbp->del(dbp, NULL, &key, 0);
+
+ switch (errno) {
+ case 0:
+ return (0);
+ case DB_NOTFOUND:
+ return (1);
+ }
+ return (-1);
+
+einval: errno = EINVAL;
+ return (-1);
+}
+
+static int
+db185_fd(db185p)
+ const DB185 *db185p;
+{
+ DB *dbp;
+ int fd;
+
+ dbp = (DB *)db185p->internal;
+
+ return ((errno = dbp->fd(dbp, &fd)) == 0 ? fd : -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;
+
+ dbp = (DB *)db185p->internal;
+
+ 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 (errno = dbp->get(dbp, NULL, &key, &data, 0)) {
+ case 0:
+ data185->data = data.data;
+ data185->size = data.size;
+ return (0);
+ case DB_NOTFOUND:
+ return (1);
+ }
+ return (-1);
+
+einval: errno = EINVAL;
+ 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 s_errno;
+
+ dbp = (DB *)db185p->internal;
+
+ 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:
+ errno = dbp->put(dbp, NULL, &key, &data, 0);
+ break;
+ case R_CURSOR:
+ errno =
+ 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 ((errno = dbp->cursor(dbp, NULL, &dbcp_put)) != 0)
+ return (-1);
+ if ((errno =
+ dbcp_put->c_get(dbcp_put, &key, &data, DB_SET)) != 0) {
+ s_errno = errno;
+ (void)dbcp_put->c_close(dbcp_put);
+ errno = s_errno;
+ return (-1);
+ }
+ memset(&data, 0, sizeof(data));
+ data.data = data185->data;
+ data.size = data185->size;
+ errno = dbcp_put->c_put(dbcp_put,
+ &key, &data, flags == R_IAFTER ? DB_AFTER : DB_BEFORE);
+ s_errno = errno;
+ (void)dbcp_put->c_close(dbcp_put);
+ errno = s_errno;
+ break;
+ case R_NOOVERWRITE:
+ errno = dbp->put(dbp, NULL, &key, &data, DB_NOOVERWRITE);
+ break;
+ case R_SETCURSOR:
+ if (dbp->type != DB_BTREE && dbp->type != DB_RECNO)
+ goto einval;
+
+ if ((errno = dbp->put(dbp, NULL, &key, &data, 0)) != 0)
+ break;
+ errno =
+ db185p->dbc->c_get(db185p->dbc, &key, &data, DB_SET_RANGE);
+ break;
+ default:
+ goto einval;
+ }
+
+ switch (errno) {
+ case 0:
+ key185->data = key.data;
+ key185->size = key.size;
+ return (0);
+ case DB_KEYEXIST:
+ return (1);
+ }
+ return (-1);
+
+einval: errno = EINVAL;
+ return (-1);
+}
+
+static int
+db185_seq(db185p, key185, data185, flags)
+ const DB185 *db185p;
+ DBT185 *key185, *data185;
+ u_int flags;
+{
+ DB *dbp;
+ DBT key, data;
+
+ dbp = (DB *)db185p->internal;
+
+ 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 (errno = 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);
+ }
+ return (-1);
+
+einval: errno = EINVAL;
+ return (-1);
+}
+
+static int
+db185_sync(db185p, flags)
+ const DB185 *db185p;
+ u_int flags;
+{
+ DB *dbp;
+
+ dbp = (DB *)db185p->internal;
+
+ switch (flags) {
+ case 0:
+ break;
+ case R_RECNOSYNC:
+ /*
+ * !!!
+ * We can't support the R_RECNOSYNC flag.
+ */
+#define RSMSG "DB: DB 1.85's R_RECNOSYNC sync flag is not supported.\n"
+ (void)write(2, RSMSG, sizeof(RSMSG) - 1);
+ goto einval;
+ default:
+ goto einval;
+ }
+
+ return ((errno = dbp->sync(dbp, 0)) == 0 ? 0 : -1);
+
+einval: errno = EINVAL;
+ return (-1);
+}
diff --git a/db2/db185/db185_int.h b/db2/db185/db185_int.h
new file mode 100644
index 0000000000..656dfddf78
--- /dev/null
+++ b/db2/db185/db185_int.h
@@ -0,0 +1,137 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 1997
+ * Sleepycat Software. All rights reserved.
+ */
+/*
+ * Copyright (c) 1990, 1993, 1994, 1995, 1996
+ * Keith Bostic. All rights reserved.
+ */
+/*
+ * Copyright (c) 1990, 1993, 1994
+ * The Regents of the University of California. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * @(#)db185_int.h 8.4 (Sleepycat) 7/27/97
+ */
+
+#ifndef _DB185_H_
+#define _DB185_H_
+
+/* Routine flags. */
+#define R_CURSOR 1 /* del, put, seq */
+#define __R_UNUSED 2 /* UNUSED */
+#define R_FIRST 3 /* seq */
+#define R_IAFTER 4 /* put (RECNO) */
+#define R_IBEFORE 5 /* put (RECNO) */
+#define R_LAST 6 /* seq (BTREE, RECNO) */
+#define R_NEXT 7 /* seq */
+#define R_NOOVERWRITE 8 /* put */
+#define R_PREV 9 /* seq (BTREE, RECNO) */
+#define R_SETCURSOR 10 /* put (RECNO) */
+#define R_RECNOSYNC 11 /* sync (RECNO) */
+
+typedef struct {
+ void *data; /* data */
+ size_t size; /* data length */
+} DBT185;
+
+/* Access method description structure. */
+typedef struct __db185 {
+ DBTYPE type; /* Underlying db type. */
+ int (*close) __P((struct __db185 *));
+ int (*del) __P((const struct __db185 *, const DBT185 *, u_int));
+ int (*get)
+ __P((const struct __db185 *, const DBT185 *, DBT185 *, u_int));
+ int (*put)
+ __P((const struct __db185 *, DBT185 *, const DBT185 *, u_int));
+ int (*seq)
+ __P((const struct __db185 *, DBT185 *, DBT185 *, u_int));
+ int (*sync) __P((const struct __db185 *, u_int));
+ void *internal; /* Access method private. */
+ int (*fd) __P((const struct __db185 *));
+
+ /*
+ * !!!
+ * Added to the end of the DB 1.85 DB structure, it's needed to
+ * hold the DB 2.0 cursor used for DB 1.85 sequential operations.
+ */
+ DBC *dbc; /* DB 1.85 sequential cursor. */
+} DB185;
+
+/* Structure used to pass parameters to the btree routines. */
+typedef struct {
+#define R_DUP 0x01 /* duplicate keys */
+ u_long flags;
+ u_int cachesize; /* bytes to cache */
+ int maxkeypage; /* maximum keys per page */
+ int minkeypage; /* minimum keys per page */
+ u_int psize; /* page size */
+ int (*compare) /* comparison function */
+ __P((const DBT *, const DBT *));
+ size_t (*prefix) /* prefix function */
+ __P((const DBT *, const DBT *));
+ int lorder; /* byte order */
+} BTREEINFO;
+
+/* Structure used to pass parameters to the hashing routines. */
+typedef struct {
+ u_int bsize; /* bucket size */
+ u_int ffactor; /* fill factor */
+ u_int nelem; /* number of elements */
+ u_int cachesize; /* bytes to cache */
+ u_int32_t /* hash function */
+ (*hash) __P((const void *, size_t));
+ int lorder; /* byte order */
+} HASHINFO;
+
+/* Structure used to pass parameters to the record routines. */
+typedef struct {
+#define R_FIXEDLEN 0x01 /* fixed-length records */
+#define R_NOKEY 0x02 /* key not required */
+#define R_SNAPSHOT 0x04 /* snapshot the input */
+ u_long flags;
+ u_int cachesize; /* bytes to cache */
+ u_int psize; /* page size */
+ int lorder; /* byte order */
+ size_t reclen; /* record length (fixed-length records) */
+ u_char bval; /* delimiting byte (variable-length records */
+ char *bfname; /* btree file name */
+} RECNOINFO;
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+DB185 *dbopen __P((const char *, int, int, DBTYPE, const void *));
+#if defined(__cplusplus)
+};
+#endif
+#endif /* !_DB185_H_ */