index/extract.c

   1 /*
   2  * Copyright (C) 1995, Index Data I/S
   3  * All rights reserved.
   4  * Sebastian Hammer, Adam Dickmeiss
   5  *
   6  * $Log: extract.c,v $
   7  * Revision 1.2  1995-09-04 09:10:34  adam
   8  * More work on index add/del/update.
   9  * Merge sort implemented.
  10  * Initial work on z39 server.
  11  *
  12  * Revision 1.1  1995/09/01  14:06:35  adam
  13  * Split of work into more files.
  14  *
  15  */
  16 #include <stdio.h>
  17 #include <assert.h>
  18 #include <unistd.h>
  19 #include <fcntl.h>
  20 #include <ctype.h>
  21
  22 #include <util.h>
  23 #include "index.h"
  24
  25 #define KEY_BUF_SIZE 100000
  26
  27 static Dict file_idx;
  28 static SYSNO sysno_next;
  29 static int key_fd = -1;
  30 static char *key_buf;
  31 static int key_offset;
  32
  33 void key_open (const char *fname)
  34 {
  35     void *file_key;
  36     if (key_fd != -1)
  37         return;
  38     if ((key_fd = open (fname, O_RDWR|O_CREAT, 0666)) == -1)
  39     {
  40         log (LOG_FATAL|LOG_ERRNO, "Creat %s", fname);
  41         exit (1);
  42     }
  43     log (LOG_DEBUG, "key_open of %s", fname);
  44     if (!(key_buf = malloc (KEY_BUF_SIZE)))
  45     {
  46         log (LOG_FATAL|LOG_ERRNO, "malloc");
  47         exit (1);
  48     }
  49     key_offset = 0;
  50     if (!(file_idx = dict_open ("fileidx", 10, 1)))
  51     {
  52         log (LOG_FATAL, "dict_open fail of %s", "fileidx");
  53         exit (1);
  54     }
  55     file_key = dict_lookup (file_idx, ".");
  56     if (file_key)
  57         memcpy (&sysno_next, (char*)file_key+1, sizeof(sysno_next));
  58     else
  59         sysno_next = 1;
  60 }
  61
  62 int key_close (void)
  63 {
  64     if (key_fd == -1)
  65     {
  66         log (LOG_DEBUG, "key_close - but no file");
  67         return 0;
  68     }
  69     close (key_fd);
  70     dict_insert (file_idx, ".", sizeof(sysno_next), &sysno_next);
  71     dict_close (file_idx);
  72     key_fd = -1;
  73     log (LOG_DEBUG, "key close - key file exist");
  74     return 1;
  75 }
  76
  77 void key_flush (void)
  78 {
  79     size_t i = 0;
  80     int w;
  81
  82     if (key_fd == -1)
  83         return;
  84     while (i < key_offset)
  85     {
  86         w = write (key_fd, key_buf + i, key_offset - i);
  87         if (w == -1)
  88         {
  89             log (LOG_FATAL|LOG_ERRNO, "Write key fail");
  90             exit (1);
  91         }
  92         i += w;
  93     }
  94     key_offset = 0;
  95 }
  96
  97 void key_write (int cmd, struct it_key *k, const char *str)
  98 {
  99     char x;
 100     size_t slen = strlen(str);
 101
 102     if (key_offset + sizeof(*k) + slen >= KEY_BUF_SIZE - 2)
 103         key_flush ();
 104     x = (cmd == 'a') ? 1 : 0;
 105     memcpy (key_buf + key_offset, str, slen+1);
 106     key_offset += slen+1;
 107     memcpy (key_buf + key_offset, &x, 1);
 108     key_offset++;
 109     memcpy (key_buf + key_offset, k, sizeof(*k));
 110     key_offset += sizeof(*k);
 111 }
 112
 113 void text_extract (SYSNO sysno, int cmd, const char *fname)
 114 {
 115     FILE *inf;
 116     struct it_key k;
 117     int seqno = 1;
 118     int c;
 119     char w[256];
 120
 121     log (LOG_DEBUG, "Text extract of %d", sysno);
 122     k.sysno = sysno;
 123     inf = fopen (fname, "r");
 124     if (!inf)
 125     {
 126         log (LOG_WARN|LOG_ERRNO, "open %s", fname);
 127         return;
 128     }
 129     while ((c=getc (inf)) != EOF)
 130     {
 131         int i = 0;
 132         while (i < 254 && c != EOF && isalnum(c))
 133         {
 134             w[i++] = c;
 135             c = getc (inf);
 136         }
 137         if (i)
 138         {
 139             w[i] = 0;
 140
 141             k.seqno = seqno++;
 142             k.field = 0;
 143             key_write (cmd, &k, w);
 144         }
 145         if (c == EOF)
 146             break;
 147     }
 148     fclose (inf);
 149 }
 150
 151 void file_extract (int cmd, const char *fname, const char *kname)
 152 {
 153     int i;
 154     char ext[128];
 155     SYSNO sysno;
 156     char ext_res[128];
 157     const char *file_type;
 158     void *file_info;
 159
 160     log (LOG_DEBUG, "%c %s k=%s", cmd, fname, kname);
 161     for (i = strlen(fname); --i >= 0; )
 162         if (fname[i] == '/')
 163         {
 164             strcpy (ext, "");
 165             break;
 166         }
 167         else if (fname[i] == '.')
 168         {
 169             strcpy (ext, fname+i+1);
 170             break;
 171         }
 172     sprintf (ext_res, "fileExtension.%s", ext);
 173     if (!(file_type = res_get (common_resource, ext_res)))
 174         return;
 175
 176     file_info = dict_lookup (file_idx, kname);
 177     if (!file_info)
 178     {
 179         sysno = sysno_next++;
 180         dict_insert (file_idx, kname, sizeof(sysno), &sysno);
 181     }
 182     else
 183         memcpy (&sysno, (char*) file_info+1, sizeof(sysno));
 184     if (!strcmp (file_type, "text"))
 185         text_extract (sysno, cmd, fname);
 186 }
 187
 188