index/recindex.c

   1 /*
   2  * Copyright (C) 1994-1999, Index Data
   3  * All rights reserved.
   4  * Sebastian Hammer, Adam Dickmeiss
   5  *
   6  * $Log: recindex.c,v $
   7  * Revision 1.32  2002-04-05 08:46:26  adam
   8  * Zebra with full functionality
   9  *
  10  * Revision 1.31  2001/02/26 22:14:59  adam
  11  * Updated for BZIP2 1.0.X. Configure script doesn't enable 64 bit LFS
  12  * on broken glibc on Redhat 7.0.
  13  *
  14  * Revision 1.30  2000/07/13 10:14:20  heikki
  15  * Removed compiler warnings when making zebra
  16  *
  17  * Revision 1.29  2000/04/05 09:49:35  adam
  18  * On Unix, zebra/z'mbol uses automake.
  19  *
  20  * Revision 1.28  1999/12/08 22:44:45  adam
  21  * Zebra/Z'mbol dependencies added.
  22  *
  23  * Revision 1.27  1999/10/29 10:02:33  adam
  24  * Fixed decompression buffer overflow.
  25  *
  26  * Revision 1.26  1999/07/06 13:34:57  adam
  27  * Fixed bug (introduced by previous commit).
  28  *
  29  * Revision 1.25  1999/07/06 12:28:04  adam
  30  * Updated record index structure. Format includes version ID. Compression
  31  * algorithm ID is stored for each record block.
  32  *
  33  * Revision 1.24  1999/06/25 13:48:02  adam
  34  * Updated MSVC project files.
  35  * Added BZIP2 record compression (not very well tested).
  36  *
  37  * Revision 1.23  1999/05/26 07:49:13  adam
  38  * C++ compilation.
  39  *
  40  * Revision 1.22  1999/02/18 12:49:34  adam
  41  * Changed file naming scheme for register files as well as record
  42  * store/index files.
  43  *
  44  * Revision 1.21  1999/02/02 14:51:03  adam
  45  * Updated WIN32 code specific sections. Changed header.
  46  *
  47  * Revision 1.20  1998/01/12 15:04:08  adam
  48  * The test option (-s) only uses read-lock (and not write lock).
  49  *
  50  * Revision 1.19  1997/09/17 12:19:16  adam
  51  * Zebra version corresponds to YAZ version 1.4.
  52  * Changed Zebra server so that it doesn't depend on global common_resource.
  53  *
  54  * Revision 1.18  1997/07/15 16:28:42  adam
  55  * Bug fix: storeData didn't work with files with multiple records.
  56  * Bug fix: fixed memory management with records; not really well
  57  *  thought through.
  58  *
  59  * Revision 1.17  1997/02/12 20:39:46  adam
  60  * Implemented options -f <n> that limits the log to the first <n>
  61  * records.
  62  * Changed some log messages also.
  63  *
  64  * Revision 1.16  1996/06/04 10:19:00  adam
  65  * Minor changes - removed include of ctype.h.
  66  *
  67  * Revision 1.15  1996/05/13  14:23:06  adam
  68  * Work on compaction of set/use bytes in dictionary.
  69  *
  70  * Revision 1.14  1996/02/01  20:48:15  adam
  71  * The total size of records are always checked in rec_cache_insert to
  72  * reduce memory usage.
  73  *
  74  * Revision 1.13  1995/12/11  09:12:49  adam
  75  * The rec_get function returns NULL if record doesn't exist - will
  76  * happen in the server if the result set records have been deleted since
  77  * the creation of the set (i.e. the search).
  78  * The server saves a result temporarily if it is 'volatile', i.e. the
  79  * set is register dependent.
  80  *
  81  * Revision 1.12  1995/12/07  17:38:47  adam
  82  * Work locking mechanisms for concurrent updates/commit.
  83  *
  84  * Revision 1.11  1995/12/06  13:58:26  adam
  85  * Improved flushing of records - all flushes except the last one
  86  * don't write the last accessed. Also flush takes place if record
  87  * info occupy more than about 256k.
  88  *
  89  * Revision 1.10  1995/12/06  12:41:24  adam
  90  * New command 'stat' for the index program.
  91  * Filenames can be read from stdin by specifying '-'.
  92  * Bug fix/enhancement of the transformation from terms to regular
  93  * expressons in the search engine.
  94  *
  95  * Revision 1.9  1995/11/30  08:34:33  adam
  96  * Started work on commit facility.
  97  * Changed a few malloc/free to xmalloc/xfree.
  98  *
  99  * Revision 1.8  1995/11/28  14:26:21  adam
 100  * Bug fix: recordId with constant wasn't right.
 101  * Bug fix: recordId dictionary entry wasn't deleted when needed.
 102  *
 103  * Revision 1.7  1995/11/28  09:09:43  adam
 104  * Zebra config renamed.
 105  * Use setting 'recordId' to identify record now.
 106  * Bug fix in recindex.c: rec_release_blocks was invokeded even
 107  * though the blocks were already released.
 108  * File traversal properly deletes records when needed.
 109  *
 110  * Revision 1.6  1995/11/25  10:24:06  adam
 111  * More record fields - they are enumerated now.
 112  * New options: flagStoreData flagStoreKey.
 113  *
 114  * Revision 1.5  1995/11/22  17:19:18  adam
 115  * Record management uses the bfile system.
 116  *
 117  * Revision 1.4  1995/11/20  16:59:46  adam
 118  * New update method: the 'old' keys are saved for each records.
 119  *
 120  * Revision 1.3  1995/11/16  15:34:55  adam
 121  * Uses new record management system in both indexer and server.
 122  *
 123  * Revision 1.2  1995/11/15  19:13:08  adam
 124  * Work on record management.
 125  *
 126  * Revision 1.1  1995/11/15  14:46:20  adam
 127  * Started work on better record management system.
 128  *
 129  */
 130
 131
 132 /*
 133  *  Format of first block
 134  *      next       (4 bytes)
 135  *      ref_count  (4 bytes)
 136  *      block      (504 bytes)
 137  *
 138  *  Format of subsequent blocks
 139  *      next  (4 bytes)
 140  *      block (508 bytes)
 141  *
 142  *  Format of each record
 143  *      sysno
 144  *      (length, data) - pairs
 145  *      length = 0 if same as previous
 146  */
 147 #include <stdio.h>
 148 #include <assert.h>
 149 #include <string.h>
 150
 151 #include "recindxp.h"
 152
 153 #if HAVE_BZLIB_H
 154 #include <bzlib.h>
 155 #endif
 156 static void rec_write_head (Records p)
 157 {
 158     int r;
 159
 160     assert (p);
 161     assert (p->index_BFile);
 162
 163     r = bf_write (p->index_BFile, 0, 0, sizeof(p->head), &p->head);
 164     if (r)
 165     {
 166         logf (LOG_FATAL|LOG_ERRNO, "write head of %s", p->index_fname);
 167         exit (1);
 168     }
 169 }
 170
 171 static void rec_tmp_expand (Records p, int size)
 172 {
 173     if (p->tmp_size < size + 2048 ||
 174         p->tmp_size < p->head.block_size[REC_BLOCK_TYPES-1]*2)
 175     {
 176         xfree (p->tmp_buf);
 177         p->tmp_size = size + p->head.block_size[REC_BLOCK_TYPES-1]*2 + 2048;
 178         p->tmp_buf = (char *) xmalloc (p->tmp_size);
 179     }
 180 }
 181
 182 static int read_indx (Records p, int sysno, void *buf, int itemsize,
 183                       int ignoreError)
 184 {
 185     int r;
 186     int pos = (sysno-1)*itemsize;
 187
 188     r = bf_read (p->index_BFile, 1+pos/128, pos%128, itemsize, buf);
 189     if (r != 1 && !ignoreError)
 190     {
 191         logf (LOG_FATAL|LOG_ERRNO, "read in %s at pos %ld",
 192               p->index_fname, (long) pos);
 193         exit (1);
 194     }
 195     return r;
 196 }
 197
 198 static void write_indx (Records p, int sysno, void *buf, int itemsize)
 199 {
 200     int pos = (sysno-1)*itemsize;
 201
 202     bf_write (p->index_BFile, 1+pos/128, pos%128, itemsize, buf);
 203 }
 204
 205 static void rec_release_blocks (Records p, int sysno)
 206 {
 207     struct record_index_entry entry;
 208     int freeblock;
 209     char block_and_ref[sizeof(short) + sizeof(int)];
 210     int dst_type;
 211     int first = 1;
 212
 213     if (read_indx (p, sysno, &entry, sizeof(entry), 1) != 1)
 214         return ;
 215
 216     freeblock = entry.next;
 217     assert (freeblock > 0);
 218     dst_type = freeblock & 7;
 219     assert (dst_type < REC_BLOCK_TYPES);
 220     freeblock = freeblock / 8;
 221     while (freeblock)
 222     {
 223         if (bf_read (p->data_BFile[dst_type], freeblock, 0,
 224                      sizeof(block_and_ref), block_and_ref) != 1)
 225         {
 226             logf (LOG_FATAL|LOG_ERRNO, "read in rec_del_single");
 227             exit (1);
 228         }
 229         if (first)
 230         {
 231             short ref;
 232             memcpy (&ref, block_and_ref + sizeof(int), sizeof(ref));
 233             --ref;
 234             memcpy (block_and_ref + sizeof(int), &ref, sizeof(ref));
 235             if (ref)
 236             {
 237                 if (bf_write (p->data_BFile[dst_type], freeblock, 0,
 238                               sizeof(block_and_ref), block_and_ref))
 239                 {
 240                     logf (LOG_FATAL|LOG_ERRNO, "write in rec_del_single");
 241                     exit (1);
 242                 }
 243                 return;
 244             }
 245             first = 0;
 246         }
 247
 248         if (bf_write (p->data_BFile[dst_type], freeblock, 0, sizeof(freeblock),
 249                       &p->head.block_free[dst_type]))
 250         {
 251             logf (LOG_FATAL|LOG_ERRNO, "write in rec_del_single");
 252             exit (1);
 253         }
 254         p->head.block_free[dst_type] = freeblock;
 255         memcpy (&freeblock, block_and_ref, sizeof(int));
 256
 257         p->head.block_used[dst_type]--;
 258     }
 259     p->head.total_bytes -= entry.size;
 260 }
 261
 262 static void rec_delete_single (Records p, Record rec)
 263 {
 264     struct record_index_entry entry;
 265
 266     rec_release_blocks (p, rec->sysno);
 267
 268     entry.next = p->head.index_free;
 269     entry.size = 0;
 270     p->head.index_free = rec->sysno;
 271     write_indx (p, rec->sysno, &entry, sizeof(entry));
 272 }
 273
 274 static void rec_write_tmp_buf (Records p, int size, int *sysnos)
 275 {
 276     struct record_index_entry entry;
 277     int no_written = 0;
 278     char *cptr = p->tmp_buf;
 279     int block_prev = -1, block_free;
 280     int dst_type = 0;
 281     int i;
 282
 283     for (i = 1; i<REC_BLOCK_TYPES; i++)
 284         if (size >= p->head.block_move[i])
 285             dst_type = i;
 286     while (no_written < size)
 287     {
 288         block_free = p->head.block_free[dst_type];
 289         if (block_free)
 290         {
 291             if (bf_read (p->data_BFile[dst_type],
 292                          block_free, 0, sizeof(*p->head.block_free),
 293                          &p->head.block_free[dst_type]) != 1)
 294             {
 295                 logf (LOG_FATAL|LOG_ERRNO, "read in %s at free block %d",
 296                       p->data_fname[dst_type], block_free);
 297                 exit (1);
 298             }
 299         }
 300         else
 301             block_free = p->head.block_last[dst_type]++;
 302         if (block_prev == -1)
 303         {
 304             entry.next = block_free*8 + dst_type;
 305             entry.size = size;
 306             p->head.total_bytes += size;
 307             while (*sysnos > 0)
 308             {
 309                 write_indx (p, *sysnos, &entry, sizeof(entry));
 310                 sysnos++;
 311             }
 312         }
 313         else
 314         {
 315             memcpy (cptr, &block_free, sizeof(int));
 316             bf_write (p->data_BFile[dst_type], block_prev, 0, 0, cptr);
 317             cptr = p->tmp_buf + no_written;
 318         }
 319         block_prev = block_free;
 320         no_written += p->head.block_size[dst_type] - sizeof(int);
 321         p->head.block_used[dst_type]++;
 322     }
 323     assert (block_prev != -1);
 324     block_free = 0;
 325     memcpy (cptr, &block_free, sizeof(int));
 326     bf_write (p->data_BFile[dst_type], block_prev, 0,
 327               sizeof(int) + (p->tmp_buf+size) - cptr, cptr);
 328 }
 329
 330 Records rec_open (BFiles bfs, int rw, int compression_method)
 331 {
 332     Records p;
 333     int i, r;
 334     int version;
 335
 336     p = (Records) xmalloc (sizeof(*p));
 337     p->compression_method = compression_method;
 338     p->rw = rw;
 339     p->tmp_size = 1024;
 340     p->tmp_buf = (char *) xmalloc (p->tmp_size);
 341     p->index_fname = "reci";
 342     p->index_BFile = bf_open (bfs, p->index_fname, 128, rw);
 343     if (p->index_BFile == NULL)
 344     {
 345         logf (LOG_FATAL|LOG_ERRNO, "open %s", p->index_fname);
 346         exit (1);
 347     }
 348     r = bf_read (p->index_BFile, 0, 0, 0, p->tmp_buf);
 349     switch (r)
 350     {
 351     case 0:
 352         memcpy (p->head.magic, REC_HEAD_MAGIC, sizeof(p->head.magic));
 353         sprintf (p->head.version, "%3d", REC_VERSION);
 354         p->head.index_free = 0;
 355         p->head.index_last = 1;
 356         p->head.no_records = 0;
 357         p->head.total_bytes = 0;
 358         for (i = 0; i<REC_BLOCK_TYPES; i++)
 359         {
 360             p->head.block_free[i] = 0;
 361             p->head.block_last[i] = 1;
 362             p->head.block_used[i] = 0;
 363         }
 364         p->head.block_size[0] = 128;
 365         p->head.block_move[0] = 0;
 366         for (i = 1; i<REC_BLOCK_TYPES; i++)
 367         {
 368             p->head.block_size[i] = p->head.block_size[i-1] * 4;
 369             p->head.block_move[i] = p->head.block_size[i] * 24;
 370         }
 371         if (rw)
 372             rec_write_head (p);
 373         break;
 374     case 1:
 375         memcpy (&p->head, p->tmp_buf, sizeof(p->head));
 376         if (memcmp (p->head.magic, REC_HEAD_MAGIC, sizeof(p->head.magic)))
 377         {
 378             logf (LOG_FATAL, "file %s has bad format", p->index_fname);
 379             exit (1);
 380         }
 381         version = atoi (p->head.version);
 382         if (version != REC_VERSION)
 383         {
 384             logf (LOG_FATAL, "file %s is version %d, but version"
 385                   " %d is required", p->index_fname, version, REC_VERSION);
 386             exit (1);
 387         }
 388         break;
 389     }
 390     for (i = 0; i<REC_BLOCK_TYPES; i++)
 391     {
 392         char str[80];
 393         sprintf (str, "recd%c", i + 'A');
 394         p->data_fname[i] = (char *) xmalloc (strlen(str)+1);
 395         strcpy (p->data_fname[i], str);
 396         p->data_BFile[i] = NULL;
 397     }
 398     for (i = 0; i<REC_BLOCK_TYPES; i++)
 399     {
 400         if (!(p->data_BFile[i] = bf_open (bfs, p->data_fname[i],
 401                                           p->head.block_size[i],
 402                                           rw)))
 403         {
 404             logf (LOG_FATAL|LOG_ERRNO, "bf_open %s", p->data_fname[i]);
 405             exit (1);
 406         }
 407     }
 408     p->cache_max = 400;
 409     p->cache_cur = 0;
 410     p->record_cache = (struct record_cache_entry *)
 411         xmalloc (sizeof(*p->record_cache)*p->cache_max);
 412     zebra_mutex_init (&p->mutex);
 413     return p;
 414 }
 415
 416 static void rec_encode_unsigned (unsigned n, unsigned char *buf, int *len)
 417 {
 418     (*len) = 0;
 419     while (n > 127)
 420     {
 421         buf[*len] = 128 + (n & 127);
 422         n = n >> 7;
 423         (*len)++;
 424     }
 425     buf[*len] = n;
 426     (*len)++;
 427 }
 428
 429 static void rec_decode_unsigned(unsigned *np, unsigned char *buf, int *len)
 430 {
 431     unsigned n = 0;
 432     unsigned w = 1;
 433     (*len) = 0;
 434
 435     while (buf[*len] > 127)
 436     {
 437         n += w*(buf[*len] & 127);
 438         w = w << 7;
 439         (*len)++;
 440     }
 441     n += w * buf[*len];
 442     (*len)++;
 443     *np = n;
 444 }
 445
 446 static void rec_cache_flush_block1 (Records p, Record rec, Record last_rec,
 447                                     char **out_buf, int *out_size,
 448                                     int *out_offset)
 449 {
 450     int i;
 451     int len;
 452
 453     for (i = 0; i<REC_NO_INFO; i++)
 454     {
 455         if (*out_offset + (int) rec->size[i] + 20 > *out_size)
 456         {
 457             int new_size = *out_offset + rec->size[i] + 65536;
 458             char *np = (char *) xmalloc (new_size);
 459             if (*out_offset)
 460                 memcpy (np, *out_buf, *out_offset);
 461             xfree (*out_buf);
 462             *out_size = new_size;
 463             *out_buf = np;
 464         }
 465         if (i == 0)
 466         {
 467             rec_encode_unsigned (rec->sysno, *out_buf + *out_offset, &len);
 468             (*out_offset) += len;
 469         }
 470         if (rec->size[i] == 0)
 471         {
 472             rec_encode_unsigned (1, *out_buf + *out_offset, &len);
 473             (*out_offset) += len;
 474         }
 475         else if (last_rec && rec->size[i] == last_rec->size[i] &&
 476                  !memcmp (rec->info[i], last_rec->info[i], rec->size[i]))
 477         {
 478             rec_encode_unsigned (0, *out_buf + *out_offset, &len);
 479             (*out_offset) += len;
 480         }
 481         else
 482         {
 483             rec_encode_unsigned (rec->size[i]+1, *out_buf + *out_offset, &len);
 484             (*out_offset) += len;
 485             memcpy (*out_buf + *out_offset, rec->info[i], rec->size[i]);
 486             (*out_offset) += rec->size[i];
 487         }
 488     }
 489 }
 490
 491 static void rec_write_multiple (Records p, int saveCount)
 492 {
 493     int i;
 494     short ref_count = 0;
 495     char compression_method;
 496     Record last_rec = 0;
 497     int out_size = 1000;
 498     int out_offset = 0;
 499     char *out_buf = (char *) xmalloc (out_size);
 500     int *sysnos = (int *) xmalloc (sizeof(*sysnos) * (p->cache_cur + 1));
 501     int *sysnop = sysnos;
 502
 503     for (i = 0; i<p->cache_cur - saveCount; i++)
 504     {
 505         struct record_cache_entry *e = p->record_cache + i;
 506         switch (e->flag)
 507         {
 508         case recordFlagNew:
 509             rec_cache_flush_block1 (p, e->rec, last_rec, &out_buf,
 510                                     &out_size, &out_offset);
 511             *sysnop++ = e->rec->sysno;
 512             ref_count++;
 513             e->flag = recordFlagNop;
 514             last_rec = e->rec;
 515             break;
 516         case recordFlagWrite:
 517             rec_release_blocks (p, e->rec->sysno);
 518             rec_cache_flush_block1 (p, e->rec, last_rec, &out_buf,
 519                                     &out_size, &out_offset);
 520             *sysnop++ = e->rec->sysno;
 521             ref_count++;
 522             e->flag = recordFlagNop;
 523             last_rec = e->rec;
 524             break;
 525         case recordFlagDelete:
 526             rec_delete_single (p, e->rec);
 527             e->flag = recordFlagNop;
 528             break;
 529         default:
 530             break;
 531         }
 532     }
 533
 534     *sysnop = -1;
 535     if (ref_count)
 536     {
 537         int csize = 0;  /* indicate compression "not performed yet" */
 538         compression_method = p->compression_method;
 539         switch (compression_method)
 540         {
 541         case REC_COMPRESS_BZIP2:
 542 #if HAVE_BZLIB_H
 543             csize = out_offset + (out_offset >> 6) + 620;
 544             rec_tmp_expand (p, csize);
 545 #ifdef BZ_CONFIG_ERROR
 546             i = BZ2_bzBuffToBuffCompress
 547 #else
 548             i = bzBuffToBuffCompress
 549 #endif
 550                                      (p->tmp_buf+sizeof(int)+sizeof(short)+
 551                                       sizeof(char),
 552                                       &csize, out_buf, out_offset, 1, 0, 30);
 553             if (i != BZ_OK)
 554             {
 555                 logf (LOG_WARN, "bzBuffToBuffCompress error code=%d", i);
 556                 csize = 0;
 557             }
 558             logf (LOG_LOG, "compress %4d %5d %5d", ref_count, out_offset,
 559                   csize);
 560 #endif
 561             break;
 562         case REC_COMPRESS_NONE:
 563             break;
 564         }
 565         if (!csize)
 566         {
 567             /* either no compression or compression not supported ... */
 568             csize = out_offset;
 569             rec_tmp_expand (p, csize);
 570             memcpy (p->tmp_buf + sizeof(int) + sizeof(short) + sizeof(char),
 571                     out_buf, out_offset);
 572             csize = out_offset;
 573             compression_method = REC_COMPRESS_NONE;
 574         }
 575         memcpy (p->tmp_buf + sizeof(int), &ref_count, sizeof(ref_count));
 576         memcpy (p->tmp_buf + sizeof(int)+sizeof(short),
 577                 &compression_method, sizeof(compression_method));
 578
 579         /* -------- compression */
 580         rec_write_tmp_buf (p, csize + sizeof(short) + sizeof(char), sysnos);
 581     }
 582     xfree (out_buf);
 583     xfree (sysnos);
 584 }
 585
 586 static void rec_cache_flush (Records p, int saveCount)
 587 {
 588     int i, j;
 589
 590     if (saveCount >= p->cache_cur)
 591         saveCount = 0;
 592
 593     rec_write_multiple (p, saveCount);
 594
 595     for (i = 0; i<p->cache_cur - saveCount; i++)
 596     {
 597         struct record_cache_entry *e = p->record_cache + i;
 598         rec_rm (&e->rec);
 599     }
 600     /* i still being used ... */
 601     for (j = 0; j<saveCount; j++, i++)
 602         memcpy (p->record_cache+j, p->record_cache+i,
 603                 sizeof(*p->record_cache));
 604     p->cache_cur = saveCount;
 605 }
 606
 607 static Record *rec_cache_lookup (Records p, int sysno,
 608                                  enum recordCacheFlag flag)
 609 {
 610     int i;
 611     for (i = 0; i<p->cache_cur; i++)
 612     {
 613         struct record_cache_entry *e = p->record_cache + i;
 614         if (e->rec->sysno == sysno)
 615         {
 616             if (flag != recordFlagNop && e->flag == recordFlagNop)
 617                 e->flag = flag;
 618             return &e->rec;
 619         }
 620     }
 621     return NULL;
 622 }
 623
 624 static void rec_cache_insert (Records p, Record rec, enum recordCacheFlag flag)
 625 {
 626     struct record_cache_entry *e;
 627
 628     if (p->cache_cur == p->cache_max)
 629         rec_cache_flush (p, 1);
 630     else if (p->cache_cur > 0)
 631     {
 632         int i, j;
 633         int used = 0;
 634         for (i = 0; i<p->cache_cur; i++)
 635         {
 636             Record r = (p->record_cache + i)->rec;
 637             for (j = 0; j<REC_NO_INFO; j++)
 638                 used += r->size[j];
 639         }
 640         if (used > 90000)
 641             rec_cache_flush (p, 1);
 642     }
 643     assert (p->cache_cur < p->cache_max);
 644
 645     e = p->record_cache + (p->cache_cur)++;
 646     e->flag = flag;
 647     e->rec = rec_cp (rec);
 648 }
 649
 650 void rec_close (Records *pp)
 651 {
 652     Records p = *pp;
 653     int i;
 654
 655     assert (p);
 656
 657     zebra_mutex_destroy (&p->mutex);
 658     rec_cache_flush (p, 0);
 659     xfree (p->record_cache);
 660
 661     if (p->rw)
 662         rec_write_head (p);
 663
 664     if (p->index_BFile)
 665         bf_close (p->index_BFile);
 666
 667     for (i = 0; i<REC_BLOCK_TYPES; i++)
 668     {
 669         if (p->data_BFile[i])
 670             bf_close (p->data_BFile[i]);
 671         xfree (p->data_fname[i]);
 672     }
 673     xfree (p->tmp_buf);
 674     xfree (p);
 675     *pp = NULL;
 676 }
 677
 678 static Record rec_get_int (Records p, int sysno)
 679 {
 680     int i, in_size, r;
 681     Record rec, *recp;
 682     struct record_index_entry entry;
 683     int freeblock, dst_type;
 684     char *nptr, *cptr;
 685     char *in_buf = 0;
 686     char *bz_buf = 0;
 687 #if HAVE_BZLIB_H
 688     int bz_size;
 689 #endif
 690     char compression_method;
 691
 692     assert (sysno > 0);
 693     assert (p);
 694
 695     if ((recp = rec_cache_lookup (p, sysno, recordFlagNop)))
 696         return rec_cp (*recp);
 697
 698     if (read_indx (p, sysno, &entry, sizeof(entry), 1) < 1)
 699         return NULL;       /* record is not there! */
 700
 701     if (!entry.size)
 702         return NULL;       /* record is deleted */
 703
 704     dst_type = entry.next & 7;
 705     assert (dst_type < REC_BLOCK_TYPES);
 706     freeblock = entry.next / 8;
 707
 708     assert (freeblock > 0);
 709
 710     rec_tmp_expand (p, entry.size);
 711
 712     cptr = p->tmp_buf;
 713     r = bf_read (p->data_BFile[dst_type], freeblock, 0, 0, cptr);
 714     if (r < 0)
 715         return 0;
 716     memcpy (&freeblock, cptr, sizeof(freeblock));
 717
 718     while (freeblock)
 719     {
 720         int tmp;
 721
 722         cptr += p->head.block_size[dst_type] - sizeof(freeblock);
 723
 724         memcpy (&tmp, cptr, sizeof(tmp));
 725         r = bf_read (p->data_BFile[dst_type], freeblock, 0, 0, cptr);
 726         if (r < 0)
 727             return 0;
 728         memcpy (&freeblock, cptr, sizeof(freeblock));
 729         memcpy (cptr, &tmp, sizeof(tmp));
 730     }
 731
 732     rec = (Record) xmalloc (sizeof(*rec));
 733     rec->sysno = sysno;
 734     memcpy (&compression_method, p->tmp_buf + sizeof(int) + sizeof(short),
 735             sizeof(compression_method));
 736     in_buf = p->tmp_buf + sizeof(int) + sizeof(short) + sizeof(char);
 737     in_size = entry.size - sizeof(short) - sizeof(char);
 738     switch (compression_method)
 739     {
 740     case REC_COMPRESS_BZIP2:
 741 #if HAVE_BZLIB_H
 742         bz_size = entry.size * 20 + 100;
 743         while (1)
 744         {
 745             bz_buf = (char *) xmalloc (bz_size);
 746 #ifdef BZ_CONFIG_ERROR
 747             i = BZ2_bzBuffToBuffDecompress
 748 #else
 749             i = bzBuffToBuffDecompress
 750 #endif
 751                  (bz_buf, &bz_size, in_buf, in_size, 0, 0);
 752             logf (LOG_LOG, "decompress %5d %5d", in_size, bz_size);
 753             if (i == BZ_OK)
 754                 break;
 755             logf (LOG_LOG, "failed");
 756             xfree (bz_buf);
 757             bz_size *= 2;
 758         }
 759         in_buf = bz_buf;
 760         in_size = bz_size;
 761 #else
 762         logf (LOG_FATAL, "cannot decompress record(s) in BZIP2 format");
 763         exit (1);
 764 #endif
 765         break;
 766     case REC_COMPRESS_NONE:
 767         break;
 768     }
 769     for (i = 0; i<REC_NO_INFO; i++)
 770         rec->info[i] = 0;
 771
 772     nptr = in_buf;                /* skip ref count */
 773     while (nptr < in_buf + in_size)
 774     {
 775         int this_sysno;
 776         int len;
 777         rec_decode_unsigned (&this_sysno, nptr, &len);
 778         nptr += len;
 779
 780         for (i = 0; i < REC_NO_INFO; i++)
 781         {
 782             int this_size;
 783             rec_decode_unsigned (&this_size, nptr, &len);
 784             nptr += len;
 785
 786             if (this_size == 0)
 787                 continue;
 788             rec->size[i] = this_size-1;
 789
 790             if (rec->size[i])
 791             {
 792                 rec->info[i] = nptr;
 793                 nptr += rec->size[i];
 794             }
 795             else
 796                 rec->info[i] = NULL;
 797         }
 798         if (this_sysno == sysno)
 799             break;
 800     }
 801     for (i = 0; i<REC_NO_INFO; i++)
 802     {
 803         if (rec->info[i] && rec->size[i])
 804         {
 805             char *np = xmalloc (rec->size[i]);
 806             memcpy (np, rec->info[i], rec->size[i]);
 807             rec->info[i] = np;
 808         }
 809         else
 810         {
 811             assert (rec->info[i] == 0);
 812             assert (rec->size[i] == 0);
 813         }
 814     }
 815     xfree (bz_buf);
 816     rec_cache_insert (p, rec, recordFlagNop);
 817     return rec;
 818 }
 819
 820 Record rec_get (Records p, int sysno)
 821 {
 822     Record rec;
 823     zebra_mutex_lock (&p->mutex);
 824
 825     rec = rec_get_int (p, sysno);
 826     zebra_mutex_unlock (&p->mutex);
 827     return rec;
 828 }
 829
 830 static Record rec_new_int (Records p)
 831 {
 832     int sysno, i;
 833     Record rec;
 834
 835     assert (p);
 836     rec = (Record) xmalloc (sizeof(*rec));
 837     if (1 || p->head.index_free == 0)
 838         sysno = (p->head.index_last)++;
 839     else
 840     {
 841         struct record_index_entry entry;
 842
 843         read_indx (p, p->head.index_free, &entry, sizeof(entry), 0);
 844         sysno = p->head.index_free;
 845         p->head.index_free = entry.next;
 846     }
 847     (p->head.no_records)++;
 848     rec->sysno = sysno;
 849     for (i = 0; i < REC_NO_INFO; i++)
 850     {
 851         rec->info[i] = NULL;
 852         rec->size[i] = 0;
 853     }
 854     rec_cache_insert (p, rec, recordFlagNew);
 855     return rec;
 856 }
 857
 858 Record rec_new (Records p)
 859 {
 860     Record rec;
 861     zebra_mutex_lock (&p->mutex);
 862
 863     rec = rec_new_int (p);
 864     zebra_mutex_unlock (&p->mutex);
 865     return rec;
 866 }
 867
 868 void rec_del (Records p, Record *recpp)
 869 {
 870     Record *recp;
 871
 872     zebra_mutex_lock (&p->mutex);
 873     (p->head.no_records)--;
 874     if ((recp = rec_cache_lookup (p, (*recpp)->sysno, recordFlagDelete)))
 875     {
 876         rec_rm (recp);
 877         *recp = *recpp;
 878     }
 879     else
 880     {
 881         rec_cache_insert (p, *recpp, recordFlagDelete);
 882         rec_rm (recpp);
 883     }
 884     zebra_mutex_unlock (&p->mutex);
 885     *recpp = NULL;
 886 }
 887
 888 void rec_put (Records p, Record *recpp)
 889 {
 890     Record *recp;
 891
 892     zebra_mutex_lock (&p->mutex);
 893     if ((recp = rec_cache_lookup (p, (*recpp)->sysno, recordFlagWrite)))
 894     {
 895         rec_rm (recp);
 896         *recp = *recpp;
 897     }
 898     else
 899     {
 900         rec_cache_insert (p, *recpp, recordFlagWrite);
 901         rec_rm (recpp);
 902     }
 903     zebra_mutex_unlock (&p->mutex);
 904     *recpp = NULL;
 905 }
 906
 907 void rec_rm (Record *recpp)
 908 {
 909     int i;
 910
 911     if (!*recpp)
 912         return ;
 913     for (i = 0; i < REC_NO_INFO; i++)
 914         xfree ((*recpp)->info[i]);
 915     xfree (*recpp);
 916     *recpp = NULL;
 917 }
 918
 919 Record rec_cp (Record rec)
 920 {
 921     Record n;
 922     int i;
 923
 924     n = (Record) xmalloc (sizeof(*n));
 925     n->sysno = rec->sysno;
 926     for (i = 0; i < REC_NO_INFO; i++)
 927         if (!rec->info[i])
 928         {
 929             n->info[i] = NULL;
 930             n->size[i] = 0;
 931         }
 932         else
 933         {
 934             n->size[i] = rec->size[i];
 935             n->info[i] = (char *) xmalloc (rec->size[i]);
 936             memcpy (n->info[i], rec->info[i], rec->size[i]);
 937         }
 938     return n;
 939 }
 940
 941
 942 char *rec_strdup (const char *s, size_t *len)
 943 {
 944     char *p;
 945
 946     if (!s)
 947     {
 948         *len = 0;
 949         return NULL;
 950     }
 951     *len = strlen(s)+1;
 952     p = (char *) xmalloc (*len);
 953     strcpy (p, s);
 954     return p;
 955 }
 956