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