index/main.c

   1 /*
   2  * Copyright (C) 1994, Index Data I/S
   3  * All rights reserved.
   4  * Sebastian Hammer, Adam Dickmeiss
   5  *
   6  * $Log: main.c,v $
   7  * Revision 1.2  1995-09-01 10:30:24  adam
   8  * More work on indexing. Not working yet.
   9  *
  10  * Revision 1.1  1995/08/31  14:50:24  adam
  11  * New simple file index tool.
  12  *
  13  */
  14 #include <stdio.h>
  15 #include <assert.h>
  16 #include <unistd.h>
  17 #include <sys/stat.h>
  18 #include <sys/types.h>
  19 #include <fcntl.h>
  20 #include <ctype.h>
  21
  22 #include <util.h>
  23 #include "index.h"
  24
  25 char *prog;
  26
  27 static int key_fd = -1;
  28 #define KEY_BUF_SIZE 100000
  29 static char *key_buf;
  30 int key_offset;
  31 SYSNO sysno_next;
  32 Dict file_idx;
  33 static char *base_path = NULL;
  34
  35 void key_open (const char *fname)
  36 {
  37     void *file_key;
  38     if (key_fd != -1)
  39         return;
  40     if ((key_fd = open (fname, O_RDWR|O_CREAT, 0666)) == -1)
  41     {
  42         log (LOG_FATAL|LOG_ERRNO, "Creat %s", fname);
  43         exit (1);
  44     }
  45     if (!(key_buf = malloc (KEY_BUF_SIZE)))
  46     {
  47         log (LOG_FATAL|LOG_ERRNO, "malloc");
  48         exit (1);
  49     }
  50     key_offset = 0;
  51     if (!(file_idx = dict_open ("fileidx", 10, 1)))
  52     {
  53         log (LOG_FATAL, "dict_open fail of %s", "fileidx");
  54         exit (1);
  55     }
  56     file_key = dict_lookup (file_idx, ".");
  57     if (file_key)
  58         memcpy (&sysno_next, (char*)file_key+1, sizeof(sysno_next));
  59     else
  60         sysno_next = 1;
  61 }
  62
  63 void key_close (void)
  64 {
  65     if (key_fd == -1)
  66         return;
  67     close (key_fd);
  68     dict_insert (file_idx, ".", sizeof(sysno_next), &sysno_next);
  69     dict_close (file_idx);
  70     key_fd = -1;
  71 }
  72
  73 void key_flush (void)
  74 {
  75     size_t i = 0;
  76     int w;
  77
  78     while (i < key_offset)
  79     {
  80         w = write (key_fd, key_buf + i, key_offset - i);
  81         if (w == -1)
  82         {
  83             log (LOG_FATAL|LOG_ERRNO, "Write key fail");
  84             exit (1);
  85         }
  86         i += w;
  87     }
  88     key_offset = 0;
  89 }
  90
  91 void key_write (int cmd, struct it_key *k, const char *str)
  92 {
  93     char x = cmd;
  94     size_t slen = strlen(str);
  95
  96     if (key_offset + sizeof(*k) + slen >= KEY_BUF_SIZE - 2)
  97         key_flush ();
  98     memcpy (key_buf + key_offset, &x, 1);
  99     key_offset++;
 100     memcpy (key_buf + key_offset, k, sizeof(*k));
 101     key_offset += sizeof(*k);
 102     memcpy (key_buf + key_offset, str, slen+1);
 103     key_offset += slen+1;
 104 }
 105
 106 void text_extract (SYSNO sysno, int cmd, const char *fname)
 107 {
 108     FILE *inf;
 109     struct it_key k;
 110     int seqno = 1;
 111     int c;
 112     char w[256];
 113
 114     log (LOG_DEBUG, "Text extract of %d", sysno);
 115     k.sysno = sysno;
 116     inf = fopen (fname, "r");
 117     if (!inf)
 118     {
 119         log (LOG_WARN|LOG_ERRNO, "open %s", fname);
 120         return;
 121     }
 122     while ((c=getc (inf)) != EOF)
 123     {
 124         int i = 0;
 125         while (i < 254 && c != EOF && isalnum(c))
 126         {
 127             w[i++] = c;
 128             c = getc (inf);
 129         }
 130         if (i)
 131         {
 132             w[i] = 0;
 133
 134             k.seqno = seqno++;
 135             k.field = 0;
 136             key_write (cmd, &k, w);
 137         }
 138         if (c == EOF)
 139             break;
 140     }
 141     fclose (inf);
 142 }
 143
 144 void file_extract (int cmd, struct stat *fs, const char *fname)
 145 {
 146     int i;
 147     char ext[128];
 148     SYSNO sysno;
 149     char ext_res[128];
 150     const char *file_type;
 151     void *file_info;
 152
 153     log (LOG_DEBUG, "%c %s", cmd, fname);
 154     return;
 155     for (i = strlen(fname); --i >= 0; )
 156         if (fname[i] == '/')
 157         {
 158             strcpy (ext, "");
 159             break;
 160         }
 161         else if (fname[i] == '.')
 162         {
 163             strcpy (ext, fname+i+1);
 164             break;
 165         }
 166     sprintf (ext_res, "fileExtension.%s", ext);
 167     if (!(file_type = res_get (common_resource, ext_res)))
 168         return;
 169
 170     file_info = dict_lookup (file_idx, fname);
 171     if (!file_info)
 172     {
 173         sysno = sysno_next++;
 174         dict_insert (file_idx, fname, sizeof(sysno), &sysno);
 175     }
 176     else
 177         memcpy (&sysno, (char*) file_info+1, sizeof(sysno));
 178     if (!strcmp (file_type, "text"))
 179         text_extract (sysno, cmd, fname);
 180 }
 181
 182 static void repository_extract_r (int cmd, char *rep)
 183 {
 184     struct dir_entry *e;
 185     int i;
 186     struct stat fs;
 187     size_t rep_len = strlen (rep);
 188
 189     e = dir_open (rep);
 190     if (!e)
 191         return;
 192     if (rep[rep_len-1] != '/')
 193         rep[rep_len] = '/';
 194     else
 195         --rep_len;
 196     for (i=0; e[i].name; i++)
 197     {
 198         if (!strcmp (e[i].name, ".") || !strcmp (e[i].name, ".."))
 199             continue;
 200         strcpy (rep +rep_len+1, e[i].name);
 201         stat (rep, &fs);
 202         switch (fs.st_mode & S_IFMT)
 203         {
 204         case S_IFREG:
 205             file_extract (cmd, &fs, rep);
 206             break;
 207         case S_IFDIR:
 208             repository_extract_r (cmd, rep);
 209             break;
 210         }
 211     }
 212     dir_free (&e);
 213 }
 214
 215 void repository_update_r (int cmd, char *dst, char *src);
 216
 217 void repository_add_tree (int cmd, char *dst, char *src)
 218 {
 219     mkdir (dst, 0755);
 220     repository_update_r (cmd, dst, src);
 221 }
 222
 223 void repository_del_tree (int cmd, char *dst, char *src)
 224 {
 225     log (LOG_DEBUG, "rmdir of %s", dst);
 226 }
 227
 228 void repository_update_r (int cmd, char *dst, char *src)
 229 {
 230     struct dir_entry *e_dst, *e_src;
 231     int i_dst = 0, i_src = 0;
 232     struct stat fs_dst, fs_src;
 233     size_t dst_len = strlen (dst);
 234     size_t src_len = strlen (src);
 235
 236     e_dst = dir_open (dst);
 237     e_src = dir_open (src);
 238
 239     if (!e_dst && !e_src)
 240         return;
 241     if (!e_dst)
 242         repository_add_tree (cmd, dst, src);
 243     else if (!e_src)
 244         repository_del_tree (cmd, dst, src);
 245
 246     dir_sort (e_src);
 247     dir_sort (e_dst);
 248
 249     if (src[src_len-1] != '/')
 250         src[src_len] = '/';
 251     else
 252         --src_len;
 253     if (dst[dst_len-1] != '/')
 254         dst[dst_len] = '/';
 255     else
 256         --dst_len;
 257     while (e_dst[i_dst].name && e_src[i_src].name)
 258     {
 259         int sd = strcmp (e_dst[i_dst].name, e_src[i_src].name);
 260
 261         strcpy (dst +dst_len+1, e_dst[i_dst].name);
 262         strcpy (src +src_len+1, e_src[i_src].name);
 263
 264         if (sd == 0)
 265         {
 266             /* check type, date, length */
 267
 268             stat (dst, &fs_dst);
 269             stat (src, &fs_src);
 270
 271             switch (fs_dst.st_mode & S_IFMT)
 272             {
 273             case S_IFREG:
 274                 if (fs_src.st_mtime != fs_dst.st_mtime)
 275                 {
 276                     file_extract ('a', &fs_src, src);
 277                     file_extract ('d', &fs_dst, dst);
 278                 }
 279                 break;
 280             case S_IFDIR:
 281                 repository_update_r (cmd, dst, src);
 282                 break;
 283             }
 284             i_src++;
 285             i_dst++;
 286         }
 287         else if (sd > 0)
 288         {
 289             stat (src, &fs_src);
 290             switch (fs_src.st_mode & S_IFMT)
 291             {
 292             case S_IFREG:
 293                 file_extract ('a', &fs_src, src);
 294                 break;
 295             case S_IFDIR:
 296                 repository_add_tree (cmd, dst, src);
 297                 break;
 298             }
 299             i_src++;
 300         }
 301         else
 302         {
 303             stat (dst, &fs_dst);
 304             switch (fs_dst.st_mode & S_IFMT)
 305             {
 306             case S_IFREG:
 307                 file_extract ('d', &fs_dst, dst);
 308                 break;
 309             case S_IFDIR:
 310                 repository_del_tree (cmd, dst, src);
 311                 break;
 312             }
 313             i_dst++;
 314         }
 315     }
 316     dir_free (&e_dst);
 317     dir_free (&e_src);
 318 }
 319
 320 void repository_traverse (int cmd, const char *rep)
 321 {
 322     char rep_tmp1[2048];
 323     char rep_tmp2[2048];
 324
 325     strcpy (rep_tmp1, rep);
 326     if (base_path)
 327     {
 328         strcpy (rep_tmp2, base_path);
 329         repository_update_r (cmd, rep_tmp2, rep_tmp1);
 330     }
 331     else
 332         repository_extract_r (cmd, rep_tmp1);
 333 }
 334
 335
 336 int main (int argc, char **argv)
 337 {
 338     int ret;
 339     int cmd = 0;
 340     char *arg;
 341     char *base_name;
 342
 343     prog = *argv;
 344     while ((ret = options ("r:v:", argv, argc, &arg)) != -2)
 345     {
 346         if (ret == 0)
 347         {
 348             if (!base_name)
 349             {
 350                 base_name = arg;
 351
 352                 common_resource = res_open (base_name);
 353                 if (!common_resource)
 354                 {
 355                     log (LOG_FATAL, "Cannot open resource `%s'", base_name);
 356                     exit (1);
 357                 }
 358             }
 359             else if(cmd == 0) /* command */
 360             {
 361                 if (!strcmp (arg, "add"))
 362                 {
 363                     cmd = 'a';
 364                 }
 365                 else if (!strcmp (arg, "del"))
 366                 {
 367                     cmd = 'd';
 368                 }
 369                 else
 370                 {
 371                     log (LOG_FATAL, "Unknown command: %s", arg);
 372                     exit (1);
 373                 }
 374             }
 375             else
 376             {
 377                 key_open ("keys.tmp");
 378                 repository_traverse (cmd, arg);
 379                 cmd = 0;
 380             }
 381         }
 382         else if (ret == 'v')
 383         {
 384             log_init (log_mask_str(arg), prog, NULL);
 385         }
 386         else if (ret == 'r')
 387         {
 388             base_path = arg;
 389         }
 390         else
 391         {
 392             log (LOG_FATAL, "Unknown option '-%s'", arg);
 393             exit (1);
 394         }
 395     }
 396     key_flush ();
 397     key_close ();
 398     exit (0);
 399 }