datdump.c

来自「db.* (pronounced dee-be star) is an adva」· C语言 代码 · 共 637 行 · 第 1/2 页

/***************************************************************************
 *                                                                         *
 * db.*                                                                    *
 * open source database, datdump utility                                   *
 *                                                                         *
 * Copyright (c) 2000 Centura Software Corporation. All rights reserved.   *
 *                                                                         *
 * Use of this software, whether in source code format, or in executable,  *
 * binary object code form, is governed by the CENTURA OPEN SOURCE LICENSE *
 * which is fully described in the LICENSE.TXT file, included within this  *
 * distribution of source code files.                                      * 
 *                                                                         *
 **************************************************************************/

/*-----------------------------------------------------------------------

    datdump.c - db.* Data File Dump Utility

    To execute:
        datdump [-h] [-x] [-f] [r#] [-sg [<mode>,]<passwd>] dbname datfile

    Where:
        -h      = Print header info only (no field info)
        -x      = Print hex dump only
        -f      = Print full formatted dump (no hex dump)
        -r#     = Print only the record at slot dddd
        -sg     = Specify encryption information
        dbname  = name of database
        datfile = name of data file to be dumped

-----------------------------------------------------------------------*/

#define MOD datdump
#include "db.star.h"
#include "version.h"

#define DATDUMP
#include "cnvfld.h"

#define MAXTEXT 1600


/* ********************** LOCAL FUNCTION DECLARATIONS **************** */

static F_ADDR phys_addr(FILE_NO, F_ADDR, DB_TASK *);
static void pr_fields(short, char *, DB_TASK *);
static void pr_filehdr(FILE_NO, DB_TCHAR *, DB_TCHAR *, DB_TASK *);
static void pr_hex(short, F_ADDR, char *, DB_TASK *);
static void pr_rechdr(short, short, DB_BOOLEAN, DB_BOOLEAN, char *, DB_TASK *);
static int  pr_record(FILE_NO, F_ADDR, DB_BOOLEAN, DB_BOOLEAN, DB_BOOLEAN, DB_TASK *);
static int  tstopt(int, char *, DB_TASK *);
static void usage(void);


/* List the valid data file names *****************************************
*/
static void list_data_files(DB_TASK *task)
{
    int i;

    vftprintf(stderr, DB_TEXT("Valid data file names are:\n"));
    for (i = 0; i < task->size_ft; i++)
    {
        if (task->file_table[i].ft_type == 'd')
            vftprintf(stderr, DB_TEXT("\t%s\n"), task->file_table[i].ft_name);
    }
}


void EXTERNAL_FCN datdump_dberr(int errnum, DB_TCHAR *errmsg)
{
    vtprintf(DB_TEXT("\n%s (errnum = %d)\n"), errmsg, errnum);
}


/* db.* Data File Dump Utility ******************************
*/
int MAIN(int argc, DB_TCHAR *argv[])
{
    DB_TCHAR    dbfname[FILENMLEN];
    DB_TCHAR   *datfile;
    DB_TCHAR   *dbname;
    DB_BOOLEAN  formatted;
    DB_BOOLEAN  header;
    DB_BOOLEAN  hex;
    FILE_NO     fno;
    F_ADDR      rno;
    F_ADDR      pz_next;
    int         i;
    int         retcode = 1;
    int         status = S_OKAY;
    DB_TASK    *task;
    SG         *sg = NULL;
#if defined(SAFEGARDE)
    DB_TCHAR   *cp;
    DB_TCHAR   *password = NULL;
    int         mode = NO_ENC;
#endif

    vtprintf(DBSTAR_UTIL_DESC(DB_TEXT("Data File Dump")));

    /* process the options */
    if (argc < 2)
    {
        usage();
        return(1);
    }

    dbname = NULL; 
    datfile = NULL;
    rno = 0L;
    formatted = header = hex = TRUE;

    for (i = 1; i < argc; ++i)
    {
        if (argv[i][0] == DB_TEXT('-'))
        {
            switch (vtotlower(argv[i][1]))
            {
                case DB_TEXT('x'):
                    formatted = header = FALSE;
                    break;

                case DB_TEXT('h'):
                    formatted = hex = FALSE;
                    break;

                case DB_TEXT('f'):
                    hex = FALSE;
                    break;

                case DB_TEXT('r'):
                    rno = vttol(&argv[i][2]);
                    break;

                case DB_TEXT('s'):
                    if (vtotlower(argv[i][2]) != DB_TEXT('g') || i == argc - 1)
                    {
                        usage();
                        return 1;
                    }

#if defined(SAFEGARDE)
                    if ((cp = vtstrchr(argv[++i], DB_TEXT(','))) != NULL)
                        *cp++ = DB_TEXT('\0');

                    if (cp)
                    {
                        if (vtstricmp(argv[i], DB_TEXT("low")) == 0)
                            mode = LOW_ENC;
                        else if (vtstricmp(argv[i], DB_TEXT("med")) == 0)
                            mode = MED_ENC;
                        else if (vtstricmp(argv[i], DB_TEXT("high")) == 0)
                            mode = HIGH_ENC;
                        else
                        {
                            usage();
                            return 1;
                        }

                        password = cp;
                    }
                    else
                    {
                        mode = MED_ENC;
                        password = argv[i];
                    }

                    break;
#else
                    vftprintf(stderr, DB_TEXT("SafeGarde is not available in this version\n"));
                    usage();
                    return 1;
#endif

                default:
                    usage();
                    return(1);
            }
        }
        else if (dbname == NULL)
            dbname = argv[i];
        else
            datfile = argv[i];
    }

    if (! dbname)
    {
        vftprintf(stderr, DB_TEXT("A database name must be supplied.\n"));
        usage();
        return(1);
    }

    if ((status = d_opentask(&task)) == S_OKAY)
    {
#if defined(SAFEGARDE)
	if (mode != NO_ENC && (sg = sg_create(mode, password)) == NULL)
	{
	    vftprintf(stderr, DB_TEXT("A SafeGarde context could not be created.\n"));
	    return 1;
	}
#endif

        if ((status = d_set_dberr(datdump_dberr, task)) == S_OKAY)
        {
            if ((status = d_on_opt(READNAMES, task)) == S_OKAY)
            {
                if ((status = d_open_sg(dbname, DB_TEXT("o"), sg, task)) == S_OKAY)
                {
                    /* make sure all components are present */
                    if (! datfile)
                    {
                        vftprintf(stderr, DB_TEXT("A data file name must be supplied.\n"));
                        list_data_files(task);   /* database must be open for this */
                    }
                    else
                    {
                        /* look up file table entry */
                        con_dbf(dbfname, datfile, dbname,
                                  get_element(task->dbfpath, 0), task);

                        for (fno = 0; fno < task->size_ft; ++fno)
                        {
                            if (psp_fileNameCmp(task->file_table[fno].ft_name,
                                    dbfname) == 0)
                                break;
                        }
                        if (fno == task->size_ft)
                        {
                            vftprintf(stderr, DB_TEXT("File '%s' not found in database %s\n"),
                                      datfile, dbname);
                            list_data_files(task);
                        }
                        else
                        {
                            if (task->file_table[fno].ft_type != 'd')
                            {
                                vftprintf(stderr, DB_TEXT("File '%s' is not a data file\n"),
                                          datfile);
                                list_data_files(task);
                            }
                            else
                            {
                                if ((status = dio_pzread(fno, task)) == S_OKAY)
                                {
                                    pz_next = task->pgzero[fno].pz_next;

                                    if (rno > 0L && rno < pz_next)
                                    {
                                        retcode = pr_record(fno, rno, formatted,
                                                                  header, hex, task);
                                    }
                                    else if (rno == 0L)
                                    {
                                        pr_filehdr(fno, datfile, dbname, task);
    
                                        /* read each record in data file */
                                        for (rno = 1L; rno < pz_next; ++rno)
                                        {
                                            if ((retcode = pr_record(fno, rno, formatted,
                                                                            header, hex, task)))
                                                break;
                                        }
                                        if (rno == pz_next)
                                        retcode = 0;
                                    }
                                    else
                                    {
                                        vftprintf(stderr, DB_TEXT("invalid record slot number\n"));
                                    }
                                }
                            }
                        }
                    }
                    d_close(task);
                }
            }
        }
        d_closetask(task);
    }
    if (status != S_OKAY)
    {
        switch (status)
        {
            case S_INVDB:
                vftprintf(stderr, DB_TEXT("Unable to locate database: %s\n"), dbname);
                break;
    
            case S_INCOMPAT:
                vftprintf(stderr, DB_TEXT("Incompatible dictionary file. Re-run ddlp.\n"));
                break;

            default:
                vftprintf(stderr, DB_TEXT("Error %d opening database.\n"), status);
                break;
        }
    }
    return(retcode);
}


/* Print record contents ***************************************************
*/
static int pr_record(
    FILE_NO fno,
    F_ADDR rno,
    DB_BOOLEAN formatted,
    DB_BOOLEAN header,
    DB_BOOLEAN hex,
    DB_TASK *task)
{
    F_ADDR       addr;
    DB_ADDR      dba;
    short     rid;
    short     rtn;
    DB_BOOLEAN   rlb;
    DB_BOOLEAN   deleted;
    char        *rec;