index/kdump.c

   1 /* $Id: kdump.c,v 1.29 2005-06-14 20:28:54 adam Exp $
   2    Copyright (C) 1995-2005
   3    Index Data ApS
   4
   5 This file is part of the Zebra server.
   6
   7 Zebra is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with Zebra; see the file LICENSE.zebra.  If not, write to the
  19 Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.
  21 */
  22
  23 #include <stdio.h>
  24 #include <string.h>
  25 #include <assert.h>
  26 #ifdef WIN32
  27 #include <io.h>
  28 #endif
  29 #if HAVE_UNISTD_H
  30 #include <unistd.h>
  31 #endif
  32 #include <assert.h>
  33
  34 #include <charmap.h>
  35 #include "index.h"
  36
  37 char *prog;
  38
  39 int main(int argc, char **argv)
  40 {
  41     exit(0);
  42 }
  43
  44 #if 0
  45 /* old kdumper.. must be updated to use new codec .. */
  46 int key_file_decode (FILE *f)
  47 {
  48     int c, d;
  49
  50     c = getc (f);
  51     switch (c & 192)
  52     {
  53     case 0:
  54         d = c;
  55         break;
  56     case 64:
  57         d = ((c&63) << 8) + (getc (f) & 0xff);
  58         break;
  59     case 128:
  60         d = ((c&63) << 8) + (getc (f) & 0xff);
  61         d = (d << 8) + (getc (f) & 0xff);
  62         break;
  63     case 192:
  64         d = ((c&63) << 8) + (getc (f) & 0xff);
  65         d = (d << 8) + (getc (f) & 0xff);
  66         d = (d << 8) + (getc (f) & 0xff);
  67         break;
  68     default:
  69         d = 0;
  70         assert (0);
  71     }
  72     return d;
  73 }
  74
  75
  76 static int read_one (FILE *inf, char *name, char *key, struct it_key *prevk)
  77 {
  78     int c;
  79     int i = 0;
  80     struct it_key itkey;
  81     do
  82     {
  83         if ((c=getc(inf)) == EOF)
  84             return 0;
  85         name[i++] = c;
  86     } while (c);
  87     if (i > 1)
  88         prevk->sysno = 0;
  89     c = key_file_decode (inf);
  90     key[0] = c & 1;
  91     c = c >> 1;
  92     itkey.sysno = c + prevk->sysno;
  93     if (c)
  94     {
  95         prevk->sysno = itkey.sysno;
  96         prevk->seqno = 0;
  97     }
  98     c = key_file_decode (inf);
  99     itkey.seqno = c + prevk->seqno;
 100     prevk->seqno = itkey.seqno;
 101
 102     memcpy (key+1, &itkey, sizeof(itkey));
 103     return 1;
 104 }
 105
 106
 107 int main (int argc, char **argv)
 108 {
 109     int ret;
 110     char *arg;
 111     char *key_fname = NULL;
 112     char key_string[IT_MAX_WORD];
 113     char key_info[256];
 114     ZebraMaps zm;
 115     FILE *inf;
 116     Res res = NULL;
 117     struct it_key prevk;
 118
 119     prevk.sysno = 0;
 120     prevk.seqno = 0;
 121
 122     prog = *argv;
 123     while ((ret = options ("c:v:", argv, argc, &arg)) != -2)
 124     {
 125         if (ret == 0)
 126         {
 127             key_fname = arg;
 128         }
 129         else if (ret == 'v')
 130         {
 131             yaz_log_init (yaz_log_mask_str(arg), prog, NULL);
 132         }
 133         else if (ret == 'c')
 134         {
 135             if (!(res = res_open (arg, 0, 0)))
 136             {
 137                 yaz_log(YLOG_FATAL, "Failed to open resource file %s", arg);
 138                 exit (1);
 139             }
 140         }
 141         else
 142         {
 143             yaz_log (YLOG_FATAL, "Unknown option '-%s'", arg);
 144             exit (1);
 145         }
 146     }
 147     if (!key_fname)
 148     {
 149         fprintf (stderr, "kdump [-c config] [-v log] file\n");
 150         exit (1);
 151     }
 152     if (!res)
 153         res = res_open ("zebra.cfg", 0, 0);
 154     zm = zebra_maps_open (res, 0);
 155     if (!(inf = fopen (key_fname, "r")))
 156     {
 157         yaz_log (YLOG_FATAL|YLOG_ERRNO, "fopen %s", key_fname);
 158         exit (1);
 159     }
 160     printf ("t  rg op  sysno seqno txt\n");
 161     while (read_one (inf, key_string, key_info, &prevk))
 162     {
 163         struct it_key k;
 164         int op;
 165         char keybuf[IT_MAX_WORD+1];
 166         char *to = keybuf;
 167         const char *from = key_string;
 168         int usedb_type = from[0];
 169         int reg_type = from[1];
 170
 171         op = key_info[0];
 172         memcpy (&k, 1+key_info, sizeof(k));
 173
 174         from += 2;
 175         while (*from)
 176         {
 177             const char *res = zebra_maps_output (zm, reg_type, &from);
 178             if (!res)
 179                 *to++ = *from++;
 180             else
 181                 while (*res)
 182                     *to++ = *res++;
 183         }
 184         *to = '\0';
 185         printf ("%c %3d %c %7d %5d %s\n", reg_type, usedb_type, op ? 'i':'d',
 186                 k.sysno, k.seqno, keybuf);
 187     }
 188     zebra_maps_close (zm);
 189     if (fclose (inf))
 190     {
 191         yaz_log (YLOG_FATAL|YLOG_ERRNO, "fclose %s", key_fname);
 192         exit (1);
 193     }
 194     exit (0);
 195 }
 196 #endif