db_load.c

/*-
 * See the file LICENSE for redistribution information.
 *
 * Copyright (c) 1996-2005
 *      Sleepycat Software.  All rights reserved.
 *
 * $Id: db_load.c,v 12.8 2005/06/16 20:21:23 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 <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#endif

#include "db_int.h"
#include "dbinc/db_page.h"
#include "dbinc/db_am.h"

typedef struct {                        /* XXX: Globals. */
        const char *progname;           /* Program name. */
        char    *hdrbuf;                /* Input file header. */
        u_long  lineno;                 /* Input file line number. */
        u_long  origline;               /* Original file line number. */
        int     endodata;               /* Reached the end of a database. */
        int     endofile;               /* Reached the end of the input. */
        int     version;                /* Input version. */
        char    *home;                  /* Env home. */
        char    *passwd;                /* Env passwd. */
        int     private;                /* Private env. */
        u_int32_t cache;                /* Env cache size. */
} LDG;

void    badend __P((DB_ENV *));
void    badnum __P((DB_ENV *));
int     configure __P((DB_ENV *, DB *, char **, char **, int *));
int     convprintable __P((DB_ENV *, char *, char **));
int     db_init __P((DB_ENV *, char *, u_int32_t, int *));
int     dbt_rdump __P((DB_ENV *, DBT *));
int     dbt_rprint __P((DB_ENV *, DBT *));
int     dbt_rrecno __P((DB_ENV *, DBT *, int));
int     dbt_to_recno __P((DB_ENV *, DBT *, db_recno_t *));
int     digitize __P((DB_ENV *, int, int *));
int     env_create __P((DB_ENV **, LDG *));
int     load __P((DB_ENV *, char *, DBTYPE, char **, u_int, LDG *, int *));
int     main __P((int, char *[]));
int     rheader __P((DB_ENV *, DB *, DBTYPE *, char **, int *, int *));
int     usage __P((void));
int     version_check __P((void));

const char *progname;

#define G(f)    ((LDG *)dbenv->app_private)->f

                                        /* Flags to the load function. */
#define LDF_NOHEADER    0x01            /* No dump header. */
#define LDF_NOOVERWRITE 0x02            /* Don't overwrite existing rows. */
#define LDF_PASSWORD    0x04            /* Encrypt created databases. */

int
main(argc, argv)
        int argc;
        char *argv[];
{
        enum { NOTSET, FILEID_RESET, LSN_RESET, STANDARD_LOAD } mode;
        extern char *optarg;
        extern int optind;
        DBTYPE dbtype;
        DB_ENV  *dbenv;
        LDG ldg;
        u_int ldf;
        int ch, existed, exitval, ret;
        char **clist, **clp;

        if ((progname = strrchr(argv[0], '/')) == NULL)
                progname = argv[0];
        else
                ++progname;

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

        ldg.progname = progname;
        ldg.lineno = 0;
        ldg.endodata = ldg.endofile = 0;
        ldg.version = 1;
        ldg.cache = MEGABYTE;
        ldg.hdrbuf = NULL;
        ldg.home = NULL;
        ldg.passwd = NULL;

        mode = NOTSET;
        ldf = 0;
        exitval = existed = 0;
        dbtype = DB_UNKNOWN;

        /* Allocate enough room for configuration arguments. */
        if ((clp = clist =
            (char **)calloc((size_t)argc + 1, sizeof(char *))) == NULL) {
                fprintf(stderr, "%s: %s\n", ldg.progname, strerror(ENOMEM));
                return (EXIT_FAILURE);
        }

        /*
         * There are two modes for db_load: -r and everything else.  The -r
         * option zeroes out the database LSN's or resets the file ID, it
         * doesn't really "load" a new database.  The functionality is in
         * db_load because we don't have a better place to put it, and we
         * don't want to create a new utility for just that functionality.
         */
        while ((ch = getopt(argc, argv, "c:f:h:nP:r:Tt:V")) != EOF)
                switch (ch) {
                case 'c':
                        if (mode != NOTSET && mode != STANDARD_LOAD)
                                return (usage());
                        mode = STANDARD_LOAD;

                        *clp++ = optarg;
                        break;
                case 'f':
                        if (mode != NOTSET && mode != STANDARD_LOAD)
                                return (usage());
                        mode = STANDARD_LOAD;

                        if (freopen(optarg, "r", stdin) == NULL) {
                                fprintf(stderr, "%s: %s: reopen: %s\n",
                                    ldg.progname, optarg, strerror(errno));
                                return (EXIT_FAILURE);
                        }
                        break;
                case 'h':
                        ldg.home = optarg;
                        break;
                case 'n':
                        if (mode != NOTSET && mode != STANDARD_LOAD)
                                return (usage());
                        mode = STANDARD_LOAD;

                        ldf |= LDF_NOOVERWRITE;
                        break;
                case 'P':
                        ldg.passwd = strdup(optarg);
                        memset(optarg, 0, strlen(optarg));
                        if (ldg.passwd == NULL) {
                                fprintf(stderr, "%s: strdup: %s\n",
                                    ldg.progname, strerror(errno));
                                return (EXIT_FAILURE);
                        }
                        ldf |= LDF_PASSWORD;
                        break;
                case 'r':
                        if (mode == STANDARD_LOAD)
                                return (usage());
                        if (strcmp(optarg, "lsn") == 0)
                                mode = LSN_RESET;
                        else if (strcmp(optarg, "fileid") == 0)
                                mode = FILEID_RESET;
                        else
                                return (usage());
                        break;
                case 'T':
                        if (mode != NOTSET && mode != STANDARD_LOAD)
                                return (usage());
                        mode = STANDARD_LOAD;

                        ldf |= LDF_NOHEADER;
                        break;
                case 't':
                        if (mode != NOTSET && mode != STANDARD_LOAD)
                                return (usage());
                        mode = STANDARD_LOAD;

                        if (strcmp(optarg, "btree") == 0) {
                                dbtype = DB_BTREE;
                                break;
                        }
                        if (strcmp(optarg, "hash") == 0) {
                                dbtype = DB_HASH;
                                break;
                        }
                        if (strcmp(optarg, "recno") == 0) {
                                dbtype = DB_RECNO;
                                break;
                        }
                        if (strcmp(optarg, "queue") == 0) {
                                dbtype = DB_QUEUE;
                                break;
                        }
                        return (usage());
                case 'V':
                        printf("%s\n", db_version(NULL, NULL, NULL));
                        return (EXIT_SUCCESS);
                case '?':
                default:
                        return (usage());
                }
        argc -= optind;
        argv += optind;

        if (argc != 1)
                return (usage());

        /* Handle possible interruptions. */
        __db_util_siginit();

        /*
         * Create an environment object initialized for error reporting, and
         * then open it.
         */
        if (env_create(&dbenv, &ldg) != 0)
                goto shutdown;

        /* If we're resetting the LSNs, that's an entirely separate path. */
        switch (mode) {
        case FILEID_RESET:
                exitval = dbenv->fileid_reset(
                    dbenv, argv[0], ldf & LDF_PASSWORD ? DB_ENCRYPT : 0);
                break;
        case LSN_RESET:
                exitval = dbenv->lsn_reset(
                    dbenv, argv[0], ldf & LDF_PASSWORD ? DB_ENCRYPT : 0);
                break;
        case NOTSET:
        case STANDARD_LOAD:
                while (!ldg.endofile)
                        if (load(dbenv, argv[0], dbtype, clist, ldf,
                            &ldg, &existed) != 0)
                                goto shutdown;
                break;
        }

        if (0) {
shutdown:       exitval = 1;
        }
        if ((ret = dbenv->close(dbenv, 0)) != 0) {
                exitval = 1;
                fprintf(stderr,
                    "%s: dbenv->close: %s\n", ldg.progname, db_strerror(ret));
        }

        /* Resend any caught signal. */
        __db_util_sigresend();
        free(clist);
        if (ldg.passwd != NULL)
                free(ldg.passwd);

        /*
         * Return 0 on success, 1 if keys existed already, and 2 on failure.
         *
         * Technically, this is wrong, because exit of anything other than
         * 0 is implementation-defined by the ANSI C standard.  I don't see
         * any good solutions that don't involve API changes.
         */
        return (exitval == 0 ? (existed == 0 ? 0 : 1) : 2);
}

/*
 * load --
 *      Load a database.
 */
int
load(dbenv, name, argtype, clist, flags, ldg, existedp)
        DB_ENV *dbenv;
        char *name, **clist;
        DBTYPE argtype;
        u_int flags;
        LDG *ldg;
        int *existedp;
{
        DB *dbp;
        DBT key, rkey, data, *readp, *writep;
        DBTYPE dbtype;
        DB_TXN *ctxn, *txn;
        db_recno_t recno, datarecno;
        u_int32_t put_flags;
        int ascii_recno, checkprint, hexkeys, keyflag, keys, resize, ret, rval;
        char *subdb;

        put_flags = LF_ISSET(LDF_NOOVERWRITE) ? DB_NOOVERWRITE : 0;
        G(endodata) = 0;

        subdb = NULL;
        ctxn = txn = NULL;
        memset(&key, 0, sizeof(DBT));
        memset(&data, 0, sizeof(DBT));
        memset(&rkey, 0, sizeof(DBT));

retry_db:
        dbtype = DB_UNKNOWN;
        keys = -1;
        hexkeys = -1;
        keyflag = -1;

        /* Create the DB object. */
        if ((ret = db_create(&dbp, dbenv, 0)) != 0) {
                dbenv->err(dbenv, ret, "db_create");
                goto err;
        }

        /* Read the header -- if there's no header, we expect flat text. */
        if (LF_ISSET(LDF_NOHEADER)) {
                checkprint = 1;
                dbtype = argtype;
        } else {
                if (rheader(dbenv,
                    dbp, &dbtype, &subdb, &checkprint, &keys) != 0)
                        goto err;
                if (G(endofile))
                        goto done;
        }

        /*
         * Apply command-line configuration changes.  (We apply command-line
         * configuration changes to all databases that are loaded, e.g., all
         * subdatabases.)
         */
        if (configure(dbenv, dbp, clist, &subdb, &keyflag))
                goto err;

        if (keys != 1) {
                if (keyflag == 1) {
                        dbp->err(dbp, EINVAL, "No keys specified in file");
                        goto err;
                }
        }
        else if (keyflag == 0) {
                dbp->err(dbp, EINVAL, "Keys specified in file");
                goto err;
        }
        else
                keyflag = 1;

        if (dbtype == DB_BTREE || dbtype == DB_HASH) {
                if (keyflag == 0)
                        dbp->err(dbp,
                            EINVAL, "Btree and Hash must specify keys");
                else
                        keyflag = 1;
        }

        if (argtype != DB_UNKNOWN) {

                if (dbtype == DB_RECNO || dbtype == DB_QUEUE)
                        if (keyflag != 1 && argtype != DB_RECNO &&
                            argtype != DB_QUEUE) {
                                dbenv->errx(dbenv,
                           "improper database type conversion specified");
                                goto err;
                        }
                dbtype = argtype;
        }

        if (dbtype == DB_UNKNOWN) {
                dbenv->errx(dbenv, "no database type specified");
                goto err;
        }

        if (keyflag == -1)
                keyflag = 0;

        /*
         * Recno keys have only been printed in hexadecimal starting
         * with db_dump format version 3 (DB 3.2).
         *
         * !!!
         * Note that version is set in rheader(), which must be called before
         * this assignment.
         */
        hexkeys = (G(version) >= 3 && keyflag == 1 && checkprint == 0);

        if (keyflag == 1 && (dbtype == DB_RECNO || dbtype == DB_QUEUE))
                ascii_recno = 1;
        else
                ascii_recno = 0;

        /* If configured with a password, encrypt databases we create. */
        if (LF_ISSET(LDF_PASSWORD) &&
            (ret = dbp->set_flags(dbp, DB_ENCRYPT)) != 0) {
                dbp->err(dbp, ret, "DB->set_flags: DB_ENCRYPT");
                goto err;
        }

#if 0
        Set application-specific btree comparison or hash functions here.
        For example:

        if ((ret = dbp->set_bt_compare(dbp, local_comparison_func)) != 0) {
                dbp->err(dbp, ret, "DB->set_bt_compare");
                goto err;
        }
        if ((ret = dbp->set_h_hash(dbp, local_hash_func)) != 0) {
                dbp->err(dbp, ret, "DB->set_h_hash");
                goto err;
        }
#endif

        /* Open the DB file. */
        if ((ret = dbp->open(dbp, NULL, name, subdb, dbtype,
            DB_CREATE | (TXN_ON(dbenv) ? DB_AUTO_COMMIT : 0),
            __db_omode("rw-rw-rw-"))) != 0) {
                dbp->err(dbp, ret, "DB->open: %s", name);
                goto err;
        }
        if (ldg->private != 0) {
                if ((ret = __db_util_cache(dbp, &ldg->cache, &resize)) != 0)
                        goto err;
                if (resize) {
                        if ((ret = dbp->close(dbp, 0)) != 0)
                                goto err;
                        dbp = NULL;
                        if ((ret = dbenv->close(dbenv, 0)) != 0)
                                goto err;
                        if ((ret = env_create(&dbenv, ldg)) != 0)
                                goto err;
                        goto retry_db;
                }
        }

        /* Initialize the key/data pair. */
        readp = writep = &key;
        if (dbtype == DB_RECNO || dbtype == DB_QUEUE) {
                key.size = sizeof(recno);
                if (keyflag) {
                        key.data = &datarecno;
                        if (checkprint) {
                                readp = &rkey;
                                goto key_data;
                        }
                } else
                        key.data = &recno;
        } else
key_data:       if ((readp->data = malloc(readp->ulen = 1024)) == NULL) {
                        dbenv->err(dbenv, ENOMEM, NULL);
                        goto err;
                }
        if ((data.data = malloc(data.ulen = 1024)) == NULL) {
                dbenv->err(dbenv, ENOMEM, NULL);
                goto err;
        }

        if (TXN_ON(dbenv) &&
            (ret = dbenv->txn_begin(dbenv, NULL, &txn, 0)) != 0)
                goto err;

        /* Get each key/data pair and add them to the database. */
        for (recno = 1; !__db_util_interrupted(); ++recno) {
                if (!keyflag) {
                        if (checkprint) {
                                if (dbt_rprint(dbenv, &data))
                                        goto err;
                        } else {
                                if (dbt_rdump(dbenv, &data))
                                        goto err;
                        }
                } else {
                        if (checkprint) {
                                if (dbt_rprint(dbenv, readp))
                                        goto err;
                                if (ascii_recno &&
                                    dbt_to_recno(dbenv, readp, &datarecno) != 0)
                                        goto err;

                                if (!G(endodata) && dbt_rprint(dbenv, &data))
                                        goto odd_count;
                        } else {
                                if (ascii_recno) {
                                        if (dbt_rrecno(dbenv, readp, hexkeys))
                                                goto err;
                                } else
                                        if (dbt_rdump(dbenv, readp))
                                                goto err;

                                if (!G(endodata) && dbt_rdump(dbenv, &data)) {
odd_count:                              dbenv->errx(dbenv,
                                            "odd number of key/data pairs");
                                        goto err;
                                }
                        }
                }
                if (G(endodata))
                        break;
retry:          if (txn != NULL)
                        if ((ret = dbenv->txn_begin(dbenv, txn, &ctxn, 0)) != 0)
                                goto err;
                switch (ret = dbp->put(dbp, ctxn, writep, &data, put_flags)) {
                case 0:
                        if (ctxn != NULL) {
                                if ((ret =
                                    ctxn->commit(ctxn, DB_TXN_NOSYNC)) != 0)
                                        goto err;
                                ctxn = NULL;
                        }
                        break;
                case DB_KEYEXIST:
                        *existedp = 1;
                        dbenv->errx(dbenv,
                            "%s: line %d: key already exists, not loaded:",
                            name,
                            !keyflag ? recno : recno * 2 - 1);

                        (void)dbenv->prdbt(&key,
                            checkprint, 0, stderr, __db_pr_callback, 0);
                        break;
                case DB_LOCK_DEADLOCK:
                        /* If we have a child txn, retry--else it's fatal. */
                        if (ctxn != NULL) {
                                if ((ret = ctxn->abort(ctxn)) != 0)
                                        goto err;
                                ctxn = NULL;
                                goto retry;
                        }
                        /* FALLTHROUGH */
                default:
                        dbenv->err(dbenv, ret, NULL);
                        if (ctxn != NULL) {
                                (void)ctxn->abort(ctxn);
                                ctxn = NULL;
                        }
                        goto err;
                }
                if (ctxn != NULL) {
                        if ((ret = ctxn->abort(ctxn)) != 0)
                                goto err;
                        ctxn = NULL;
                }
        }
done:   rval = 0;
        DB_ASSERT(ctxn == NULL);
        if (txn != NULL && (ret = txn->commit(txn, 0)) != 0) {
                txn = NULL;
                goto err;
        }

        if (0) {
err:            rval = 1;
                DB_ASSERT(ctxn == NULL);
                if (txn != NULL)
                        (void)txn->abort(txn);
        }

        /* Close the database. */
        if (dbp != NULL && (ret = dbp->close(dbp, 0)) != 0) {
                dbenv->err(dbenv, ret, "DB->close");
                rval = 1;
        }

        if (G(hdrbuf) != NULL)
                free(G(hdrbuf));
        G(hdrbuf) = NULL;
        /* Free allocated memory. */
        if (subdb != NULL)
                free(subdb);
        if (dbtype != DB_RECNO && dbtype != DB_QUEUE && key.data != NULL)
                free(key.data);
        if (rkey.data != NULL)
                free(rkey.data);
        free(data.data);

        return (rval);
}

/*
 * env_create --
 *      Create the environment and initialize it for error reporting.
 */
int
env_create(dbenvp, ldg)
        DB_ENV **dbenvp;
        LDG *ldg;
{
        DB_ENV *dbenv;
        int ret;

        if ((ret = db_env_create(dbenvp, 0)) != 0) {
                fprintf(stderr,
                    "%s: db_env_create: %s\n", ldg->progname, db_strerror(ret));
                return (ret);
        }
        dbenv = *dbenvp;
        dbenv->set_errfile(dbenv, stderr);
        dbenv->set_errpfx(dbenv, ldg->progname);
        if (ldg->passwd != NULL && (ret = dbenv->set_encrypt(dbenv,
            ldg->passwd, DB_ENCRYPT_AES)) != 0) {
                dbenv->err(dbenv, ret, "set_passwd");
                return (ret);
        }
        if ((ret = db_init(dbenv, ldg->home, ldg->cache, &ldg->private)) != 0)
                return (ret);
        dbenv->app_private = ldg;

        return (0);
}

/*
 * db_init --
 *      Initialize the environment.
 */
int
db_init(dbenv, home, cache, is_private)
        DB_ENV *dbenv;
        char *home;
        u_int32_t cache;
        int *is_private;
{
        u_int32_t flags;
        int ret;

        *is_private = 0;
        /* We may be loading into a live environment.  Try and join. */
        flags = DB_USE_ENVIRON |
            DB_INIT_LOCK | DB_INIT_LOG | DB_INIT_MPOOL | DB_INIT_TXN;
        if ((ret = dbenv->open(dbenv, home, flags, 0)) == 0)
                return (0);
        if (ret == DB_VERSION_MISMATCH)
                goto err;

        /*
         * We're trying to load a database.
         *
         * An environment is required because we may be trying to look at
         * databases in directories other than the current one.  We could
         * avoid using an environment iff the -h option wasn't specified,
         * but that seems like more work than it's worth.
         *
         * No environment exists (or, at least no environment that includes
         * an mpool region exists).  Create one, but make it private so that
         * no files are actually created.
         */
        LF_CLR(DB_INIT_LOCK | DB_INIT_LOG | DB_INIT_TXN);
        LF_SET(DB_CREATE | DB_PRIVATE);
        *is_private = 1;
        if ((ret = dbenv->set_cachesize(dbenv, 0, cache, 1)) != 0) {
                dbenv->err(dbenv, ret, "set_cachesize");
                return (1);
        }
        if ((ret = dbenv->open(dbenv, home, flags, 0)) == 0)
                return (0);

        /* An environment is required. */
err:    dbenv->err(dbenv, ret, "DB_ENV->open");
        return (1);
}

#define FLAG(name, value, keyword, flag)                                \
        if (strcmp(name, keyword) == 0) {                               \
                switch (*value) {                                       \
                case '1':                                               \
                        if ((ret = dbp->set_flags(dbp, flag)) != 0) {   \
                                dbp->err(dbp, ret, "%s: set_flags: %s", \
                                    G(progname), name);                 \
                                goto err;                               \
                        }                                               \
                        break;                                          \
                case '0':                                               \
                        break;                                          \
                default:                                                \
                        badnum(dbenv);                                  \
                        goto err;                                       \
                }                                                       \
                continue;                                               \
        }
#define NUMBER(name, value, keyword, func, t)                           \
        if (strcmp(name, keyword) == 0) {                               \
                if ((ret = __db_getlong(dbenv,                          \
                    NULL, value, 0, LONG_MAX, &val)) != 0 ||            \
                    (ret = dbp->func(dbp, (t)val)) != 0)                \
                        goto nameerr;                                   \
                continue;                                               \
        }
#define STRING(name, value, keyword, func)                              \
        if (strcmp(name, keyword) == 0) {                               \
                if ((ret = dbp->func(dbp, value[0])) != 0)              \
                        goto nameerr;                                   \
                continue;                                               \
        }

/*
 * configure --
 *      Handle command-line configuration options.
 */
int
configure(dbenv, dbp, clp, subdbp, keysp)
        DB_ENV *dbenv;
        DB *dbp;
        char **clp, **subdbp;
        int *keysp;
{
        long val;
        int ret, savech;
        char *name, *value;

        for (; (name = *clp) != NULL; *--value = savech, ++clp) {
                if ((value = strchr(name, '=')) == NULL) {
                        dbp->errx(dbp,
                    "command-line configuration uses name=value format");
                        return (1);
                }
                savech = *value;
                *value++ = '\0';

                if (strcmp(name, "database") == 0 ||
                    strcmp(name, "subdatabase") == 0) {
                        if (*subdbp != NULL)
                                free(*subdbp);
                        if ((*subdbp = strdup(value)) == NULL) {
                                dbp->err(dbp, ENOMEM, NULL);
                                return (1);
                        }
                        continue;
                }
                if (strcmp(name, "keys") == 0) {
                        if (strcmp(value, "1") == 0)
                                *keysp = 1;
                        else if (strcmp(value, "0") == 0)
                                *keysp = 0;
                        else {
                                badnum(dbenv);
                                return (1);
                        }
                        continue;
                }

                NUMBER(name, value, "bt_minkey", set_bt_minkey, u_int32_t);
                NUMBER(name, value, "db_lorder", set_lorder, int);
                NUMBER(name, value, "db_pagesize", set_pagesize, u_int32_t);
                FLAG(name, value, "chksum", DB_CHKSUM);
                FLAG(name, value, "duplicates", DB_DUP);
                FLAG(name, value, "dupsort", DB_DUPSORT);
                NUMBER(name, value, "h_ffactor", set_h_ffactor, u_int32_t);
                NUMBER(name, value, "h_nelem", set_h_nelem, u_int32_t);
                NUMBER(name, value, "re_len", set_re_len, u_int32_t);
                STRING(name, value, "re_pad", set_re_pad);
                FLAG(name, value, "recnum", DB_RECNUM);
                FLAG(name, value, "renumber", DB_RENUMBER);

                dbp->errx(dbp,
                    "unknown command-line configuration keyword \"%s\"", name);
                return (1);
        }
        return (0);

nameerr:
        dbp->err(dbp, ret, "%s: %s=%s", G(progname), name, value);
err:    return (1);
}

/*
 * rheader --
 *      Read the header message.
 */
int
rheader(dbenv, dbp, dbtypep, subdbp, checkprintp, keysp)
        DB_ENV *dbenv;
        DB *dbp;
        DBTYPE *dbtypep;
        char **subdbp;
        int *checkprintp, *keysp;
{
        size_t buflen, linelen, start;
        long val;
        int ch, first, hdr, ret;
        char *buf, *name, *p, *value;

        *dbtypep = DB_UNKNOWN;
        *checkprintp = 0;
        name = NULL;

        /*
         * We start with a smallish buffer;  most headers are small.
         * We may need to realloc it for a large subdatabase name.
         */
        buflen = 4096;
        if (G(hdrbuf) == NULL) {
                hdr = 0;
                if ((buf = malloc(buflen)) == NULL)
                        goto memerr;
                G(hdrbuf) = buf;
                G(origline) = G(lineno);
        } else {
                hdr = 1;
                buf = G(hdrbuf);
                G(lineno) = G(origline);
        }

        start = 0;
        for (first = 1;; first = 0) {
                ++G(lineno);

                /* Read a line, which may be of arbitrary length, into buf. */
                linelen = 0;
                buf = &G(hdrbuf)[start];
                if (hdr == 0) {
                        for (;;) {
                                if ((ch = getchar()) == EOF) {
                                        if (!first || ferror(stdin))
                                                goto badfmt;
                                        G(endofile) = 1;
                                        break;
                                }

                                /*
                                 * If the buffer is too small, double it.
                                 */
                                if (linelen + start == buflen) {
                                        G(hdrbuf) =
                                            realloc(G(hdrbuf), buflen *= 2);
                                        if (G(hdrbuf) == NULL)
                                                goto memerr;
                                        buf = &G(hdrbuf)[start];
                                }

                                if (ch == '\n')
                                        break;

                                buf[linelen++] = ch;
                        }
                        if (G(endofile) == 1)
                                break;
                        buf[linelen++] = '\0';
                } else
                        linelen = strlen(buf) + 1;
                start += linelen;

                if (name != NULL) {
                        free(name);
                        name = NULL;
                }
                /* If we don't see the expected information, it's an error. */
                if ((name = strdup(buf)) == NULL)
                        goto memerr;
                if ((p = strchr(name, '=')) == NULL)
                        goto badfmt;
                *p++ = '\0';

                value = p--;

                if (name[0] == '\0' || value[0] == '\0')
                        goto badfmt;

                if (strcmp(name, "HEADER") == 0)
                        break;
                if (strcmp(name, "VERSION") == 0) {
                        /*
                         * Version 1 didn't have a "VERSION" header line.  We
                         * only support versions 1, 2, and 3 of the dump format.
                         */
                        G(version) = atoi(value);

                        if (G(version) > 3) {
                                dbp->errx(dbp,
                                    "line %lu: VERSION %d is unsupported",
                                    G(lineno), G(version));
                                goto err;
                        }
                        continue;
                }
                if (strcmp(name, "format") == 0) {
                        if (strcmp(value, "bytevalue") == 0) {
                                *checkprintp = 0;
                                continue;
                        }
                        if (strcmp(value, "print") == 0) {
                                *checkprintp = 1;
                                continue;
                        }
                        goto badfmt;
                }
                if (strcmp(name, "type") == 0) {
                        if (strcmp(value, "btree") == 0) {
                                *dbtypep = DB_BTREE;
                                continue;
                        }
                        if (strcmp(value, "hash") == 0) {
                                *dbtypep = DB_HASH;
                                continue;
                        }
                        if (strcmp(value, "recno") == 0) {
                                *dbtypep = DB_RECNO;
                                continue;
                        }
                        if (strcmp(value, "queue") == 0) {
                                *dbtypep = DB_QUEUE;
                                continue;
                        }
                        dbp->errx(dbp, "line %lu: unknown type", G(lineno));
                        goto err;
                }
                if (strcmp(name, "database") == 0 ||
                    strcmp(name, "subdatabase") == 0) {
                        if ((ret = convprintable(dbenv, value, subdbp)) != 0) {
                                dbp->err(dbp, ret, "error reading db name");
                                goto err;
                        }
                        continue;
                }
                if (strcmp(name, "keys") == 0) {
                        if (strcmp(value, "1") == 0)
                                *keysp = 1;
                        else if (strcmp(value, "0") == 0)
                                *keysp = 0;
                        else {
                                badnum(dbenv);
                                goto err;
                        }
                        continue;
                }

#ifdef notyet
                NUMBER(name, value, "bt_maxkey", set_bt_maxkey, u_int32_t);
#endif
                NUMBER(name, value, "bt_minkey", set_bt_minkey, u_int32_t);
                NUMBER(name, value, "db_lorder", set_lorder, int);
                NUMBER(name, value, "db_pagesize", set_pagesize, u_int32_t);
                NUMBER(name, value, "extentsize", set_q_extentsize, u_int32_t);
                FLAG(name, value, "chksum", DB_CHKSUM);
                FLAG(name, value, "duplicates", DB_DUP);
                FLAG(name, value, "dupsort", DB_DUPSORT);
                NUMBER(name, value, "h_ffactor", set_h_ffactor, u_int32_t);
                NUMBER(name, value, "h_nelem", set_h_nelem, u_int32_t);
                NUMBER(name, value, "re_len", set_re_len, u_int32_t);
                STRING(name, value, "re_pad", set_re_pad);
                FLAG(name, value, "recnum", DB_RECNUM);
                FLAG(name, value, "renumber", DB_RENUMBER);

                dbp->errx(dbp,
                    "unknown input-file header configuration keyword \"%s\"",
                    name);
                goto err;
        }
        ret = 0;

        if (0) {
nameerr:        dbp->err(dbp, ret, "%s: %s=%s", G(progname), name, value);
                ret = 1;
        }
        if (0) {
badfmt:         dbp->errx(dbp, "line %lu: unexpected format", G(lineno));
                ret = 1;
        }
        if (0) {
memerr:         dbp->errx(dbp, "unable to allocate memory");
err:            ret = 1;
        }
        if (name != NULL)
                free(name);
        return (ret);
}

/*
 * convprintable --
 *      Convert a printable-encoded string into a newly allocated string.
 *
 * In an ideal world, this would probably share code with dbt_rprint, but
 * that's set up to read character-by-character (to avoid large memory
 * allocations that aren't likely to be a problem here), and this has fewer
 * special cases to deal with.
 *
 * Note that despite the printable encoding, the char * interface to this
 * function (which is, not coincidentally, also used for database naming)
 * means that outstr cannot contain any nuls.
 */
int
convprintable(dbenv, instr, outstrp)
        DB_ENV *dbenv;
        char *instr, **outstrp;
{
        char c, *outstr;
        int e1, e2;

        /*
         * Just malloc a string big enough for the whole input string;
         * the output string will be smaller (or of equal length).
         */
        if ((outstr = malloc(strlen(instr) + 1)) == NULL)
                return (ENOMEM);

        *outstrp = outstr;

        e1 = e2 = 0;
        for ( ; *instr != '\0'; instr++)
                if (*instr == '\\') {
                        if (*++instr == '\\') {
                                *outstr++ = '\\';
                                continue;
                        }
                        c = digitize(dbenv, *instr, &e1) << 4;
                        c |= digitize(dbenv, *++instr, &e2);
                        if (e1 || e2) {
                                badend(dbenv);
                                return (EINVAL);
                        }

                        *outstr++ = c;
                } else
                        *outstr++ = *instr;

        *outstr = '\0';

        return (0);
}

/*
 * dbt_rprint --
 *      Read a printable line into a DBT structure.
 */
int
dbt_rprint(dbenv, dbtp)
        DB_ENV *dbenv;
        DBT *dbtp;
{
        u_int32_t len;
        u_int8_t *p;
        int c1, c2, e, escape, first;
        char buf[32];

        ++G(lineno);

        first = 1;
        e = escape = 0;
        for (p = dbtp->data, len = 0; (c1 = getchar()) != '\n';) {
                if (c1 == EOF) {
                        if (len == 0) {
                                G(endofile) = G(endodata) = 1;
                                return (0);
                        }
                        badend(dbenv);
                        return (1);
                }
                if (first) {
                        first = 0;
                        if (G(version) > 1) {
                                if (c1 != ' ') {
                                        buf[0] = c1;
                                        if (fgets(buf + 1,
                                            sizeof(buf) - 1, stdin) == NULL ||
                                            strcmp(buf, "DATA=END\n") != 0) {
                                                badend(dbenv);
                                                return (1);
                                        }
                                        G(endodata) = 1;
                                        return (0);
                                }
                                continue;
                        }
                }
                if (escape) {
                        if (c1 != '\\') {
                                if ((c2 = getchar()) == EOF) {
                                        badend(dbenv);
                                        return (1);
                                }
                                c1 = digitize(dbenv,
                                    c1, &e) << 4 | digitize(dbenv, c2, &e);
                                if (e)
                                        return (1);
                        }
                        escape = 0;
                } else
                        if (c1 == '\\') {
                                escape = 1;
                                continue;
                        }
                if (len >= dbtp->ulen - 10) {
                        dbtp->ulen *= 2;
                        if ((dbtp->data =
                            realloc(dbtp->data, dbtp->ulen)) == NULL) {
                                dbenv->err(dbenv, ENOMEM, NULL);
                                return (1);
                        }
                        p = (u_int8_t *)dbtp->data + len;
                }
                ++len;
                *p++ = c1;
        }
        dbtp->size = len;

        return (0);
}

/*
 * dbt_rdump --
 *      Read a byte dump line into a DBT structure.
 */
int
dbt_rdump(dbenv, dbtp)
        DB_ENV *dbenv;
        DBT *dbtp;
{
        u_int32_t len;
        u_int8_t *p;
        int c1, c2, e, first;
        char buf[32];

        ++G(lineno);

        first = 1;
        e = 0;
        for (p = dbtp->data, len = 0; (c1 = getchar()) != '\n';) {
                if (c1 == EOF) {
                        if (len == 0) {
                                G(endofile) = G(endodata) = 1;
                                return (0);
                        }
                        badend(dbenv);
                        return (1);
                }
                if (first) {
                        first = 0;
                        if (G(version) > 1) {
                                if (c1 != ' ') {
                                        buf[0] = c1;
                                        if (fgets(buf + 1,
                                            sizeof(buf) - 1, stdin) == NULL ||
                                            strcmp(buf, "DATA=END\n") != 0) {
                                                badend(dbenv);
                                                return (1);
                                        }
                                        G(endodata) = 1;
                                        return (0);
                                }
                                continue;
                        }
                }
                if ((c2 = getchar()) == EOF) {
                        badend(dbenv);
                        return (1);
                }
                if (len >= dbtp->ulen - 10) {
                        dbtp->ulen *= 2;
                        if ((dbtp->data =
                            realloc(dbtp->data, dbtp->ulen)) == NULL) {
                                dbenv->err(dbenv, ENOMEM, NULL);
                                return (1);
                        }
                        p = (u_int8_t *)dbtp->data + len;
                }
                ++len;
                *p++ = digitize(dbenv, c1, &e) << 4 | digitize(dbenv, c2, &e);
                if (e)
                        return (1);
        }
        dbtp->size = len;

        return (0);
}

/*
 * dbt_rrecno --
 *      Read a record number dump line into a DBT structure.
 */
int
dbt_rrecno(dbenv, dbtp, ishex)
        DB_ENV *dbenv;
        DBT *dbtp;
        int ishex;
{
        char buf[32], *p, *q;
        u_long recno;

        ++G(lineno);

        if (fgets(buf, sizeof(buf), stdin) == NULL) {
                G(endofile) = G(endodata) = 1;
                return (0);
        }

        if (strcmp(buf, "DATA=END\n") == 0) {
                G(endodata) = 1;
                return (0);
        }

        if (buf[0] != ' ')
                goto bad;

        /*
         * If we're expecting a hex key, do an in-place conversion
         * of hex to straight ASCII before calling __db_getulong().
         */
        if (ishex) {
                for (p = q = buf + 1; *q != '\0' && *q != '\n';) {
                        /*
                         * 0-9 in hex are 0x30-0x39, so this is easy.
                         * We should alternate between 3's and [0-9], and
                         * if the [0-9] are something unexpected,
                         * __db_getulong will fail, so we only need to catch
                         * end-of-string conditions.
                         */
                        if (*q++ != '3')
                                goto bad;
                        if (*q == '\n' || *q == '\0')
                                goto bad;
                        *p++ = *q++;
                }
                *p = '\0';
        }

        if (__db_getulong(dbenv, G(progname), buf + 1, 0, 0, &recno)) {
bad:            badend(dbenv);
                return (1);
        }

        *((db_recno_t *)dbtp->data) = recno;
        dbtp->size = sizeof(db_recno_t);
        return (0);
}

int
dbt_to_recno(dbenv, dbt, recnop)
        DB_ENV *dbenv;
        DBT *dbt;
        db_recno_t *recnop;
{
        char buf[32];                           /* Large enough for 2^64. */

        memcpy(buf, dbt->data, dbt->size);
        buf[dbt->size] = '\0';

        return (__db_getulong(dbenv, G(progname), buf, 0, 0, (u_long *)recnop));
}

/*
 * digitize --
 *      Convert a character to an integer.
 */
int
digitize(dbenv, c, errorp)
        DB_ENV *dbenv;
        int c, *errorp;
{
        switch (c) {                    /* Don't depend on ASCII ordering. */
        case '0': return (0);
        case '1': return (1);
        case '2': return (2);
        case '3': return (3);
        case '4': return (4);
        case '5': return (5);
        case '6': return (6);
        case '7': return (7);
        case '8': return (8);
        case '9': return (9);
        case 'a': return (10);
        case 'b': return (11);
        case 'c': return (12);
        case 'd': return (13);
        case 'e': return (14);
        case 'f': return (15);
        default:                        /* Not possible. */
                break;
        }

        dbenv->errx(dbenv, "unexpected hexadecimal value");
        *errorp = 1;

        return (0);
}

/*
 * badnum --
 *      Display the bad number message.
 */
void
badnum(dbenv)
        DB_ENV *dbenv;
{
        dbenv->errx(dbenv,
            "boolean name=value pairs require a value of 0 or 1");
}

/*
 * badend --
 *      Display the bad end to input message.
 */
void
badend(dbenv)
        DB_ENV *dbenv;
{
        dbenv->errx(dbenv, "unexpected end of input data or key/data pair");
}

/*
 * usage --
 *      Display the usage message.
 */
int
usage()
{
        (void)fprintf(stderr, "usage: %s %s\n\t%s\n", progname,
            "[-nTV] [-c name=value] [-f file]",
    "[-h home] [-P password] [-t btree | hash | recno | queue] db_file");
        (void)fprintf(stderr, "usage: %s %s\n",
            progname, "-r lsn | fileid [-h home] [-P password] db_file");
        return (EXIT_FAILURE);
}

int
version_check()
{
        int v_major, v_minor, v_patch;

        /* Make sure we're loaded with the right version of the DB library. */
        (void)db_version(&v_major, &v_minor, &v_patch);
        if (v_major != DB_VERSION_MAJOR || v_minor != DB_VERSION_MINOR) {
                fprintf(stderr,
        "%s: version %d.%d doesn't match library version %d.%d\n",
                    progname, DB_VERSION_MAJOR, DB_VERSION_MINOR,
                    v_major, v_minor);
                return (EXIT_FAILURE);
        }
        return (0);
}

---