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