index/recindex.c

   1 /* $Id: recindex.c,v 1.46 2005-08-22 08:18:43 adam Exp $
   2    Copyright (C) 1995-2005
   3    Index Data ApS
   4
   5 This file is part of the Zebra server.
   6
   7 Zebra is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with Zebra; see the file LICENSE.zebra.  If not, write to the
  19 Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.
  21 */
  22
  23 #define RIDX_CHUNK 128
  24
  25 /*
  26  *  Format of first block
  27  *      next       (8 bytes)
  28  *      ref_count  (2 bytes)
  29  *      block      (500 bytes)
  30  *
  31  *  Format of subsequent blocks
  32  *      next  (8 bytes)
  33  *      block (502 bytes)
  34  *
  35  *  Format of each record
  36  *      sysno
  37  *      (length, data) - pairs
  38  *      length = 0 if same as previous
  39  */
  40 #include <stdio.h>
  41 #include <stdlib.h>
  42 #include <assert.h>
  43 #include <string.h>
  44
  45 #include <yaz/yaz-util.h>
  46 #include "recindxp.h"
  47
  48 #if HAVE_BZLIB_H
  49 #include <bzlib.h>
  50 #endif
  51
  52 /* Modify argument to if below: 1=normal, 0=sysno testing */
  53 #if 1
  54 /* If this is used sysno are not converted (no testing) */
  55 #define FAKE_OFFSET 0
  56 #define USUAL_RANGE 6000000000LL
  57
  58 #else
  59 /* Use a fake > 2^32 offset so we can test for proper 64-bit handling */
  60 #define FAKE_OFFSET 6000000000LL
  61 #define USUAL_RANGE 2000000000LL
  62 #endif
  63
  64 static SYSNO rec_sysno_to_ext(SYSNO sysno)
  65 {
  66     assert(sysno >= 0 && sysno <= USUAL_RANGE);
  67     return sysno + FAKE_OFFSET;
  68 }
  69
  70 SYSNO rec_sysno_to_int(SYSNO sysno)
  71 {
  72     assert(sysno >= FAKE_OFFSET && sysno <= FAKE_OFFSET + USUAL_RANGE);
  73     return sysno - FAKE_OFFSET;
  74 }
  75
  76 static void rec_write_head(Records p)
  77 {
  78     int r;
  79
  80     assert(p);
  81     assert(p->index_BFile);
  82
  83     r = bf_write(p->index_BFile, 0, 0, sizeof(p->head), &p->head);
  84     if (r)
  85     {
  86         yaz_log(YLOG_FATAL|YLOG_ERRNO, "write head of %s", p->index_fname);
  87         exit(1);
  88     }
  89 }
  90
  91 static void rec_tmp_expand(Records p, int size)
  92 {
  93     if (p->tmp_size < size + 2048 ||
  94         p->tmp_size < p->head.block_size[REC_BLOCK_TYPES-1]*2)
  95     {
  96         xfree(p->tmp_buf);
  97         p->tmp_size = size + (int)
  98                         (p->head.block_size[REC_BLOCK_TYPES-1])*2 + 2048;
  99         p->tmp_buf = (char *) xmalloc(p->tmp_size);
 100     }
 101 }
 102
 103 static int read_indx(Records p, SYSNO sysno, void *buf, int itemsize,
 104                       int ignoreError)
 105 {
 106     int r;
 107     zint pos = (sysno-1)*itemsize;
 108     int off = (int) (pos%RIDX_CHUNK);
 109     int sz1 = RIDX_CHUNK - off;    /* sz1 is size of buffer to read.. */
 110
 111     if (sz1 > itemsize)
 112         sz1 = itemsize;  /* no more than itemsize bytes */
 113
 114     r = bf_read(p->index_BFile, 1+pos/RIDX_CHUNK, off, sz1, buf);
 115     if (r == 1 && sz1 < itemsize) /* boundary? - must read second part */
 116         r = bf_read(p->index_BFile, 2+pos/RIDX_CHUNK, 0, itemsize - sz1,
 117                         (char*) buf + sz1);
 118     if (r != 1 && !ignoreError)
 119     {
 120         yaz_log(YLOG_FATAL|YLOG_ERRNO, "read in %s at pos %ld",
 121               p->index_fname, (long) pos);
 122         exit(1);
 123     }
 124     return r;
 125 }
 126
 127 static void write_indx(Records p, SYSNO sysno, void *buf, int itemsize)
 128 {
 129     zint pos = (sysno-1)*itemsize;
 130     int off = (int) (pos%RIDX_CHUNK);
 131     int sz1 = RIDX_CHUNK - off;    /* sz1 is size of buffer to read.. */
 132
 133     if (sz1 > itemsize)
 134         sz1 = itemsize;  /* no more than itemsize bytes */
 135
 136     bf_write(p->index_BFile, 1+pos/RIDX_CHUNK, off, sz1, buf);
 137     if (sz1 < itemsize)   /* boundary? must write second part */
 138         bf_write(p->index_BFile, 2+pos/RIDX_CHUNK, 0, itemsize - sz1,
 139                 (char*) buf + sz1);
 140 }
 141
 142 static void rec_release_blocks(Records p, SYSNO sysno)
 143 {
 144     struct record_index_entry entry;
 145     zint freeblock;
 146     char block_and_ref[sizeof(zint) + sizeof(short)];
 147     int dst_type;
 148     int first = 1;
 149
 150     if (read_indx(p, sysno, &entry, sizeof(entry), 1) != 1)
 151         return ;
 152
 153     freeblock = entry.next;
 154     assert(freeblock > 0);
 155     dst_type = (int) (freeblock & 7);
 156     assert(dst_type < REC_BLOCK_TYPES);
 157     freeblock = freeblock / 8;
 158     while (freeblock)
 159     {
 160         if (bf_read(p->data_BFile[dst_type], freeblock, 0,
 161                      first ? sizeof(block_and_ref) : sizeof(zint),
 162                      block_and_ref) != 1)
 163         {
 164             yaz_log(YLOG_FATAL|YLOG_ERRNO, "read in rec_del_single");
 165             exit(1);
 166         }
 167         if (first)
 168         {
 169             short ref;
 170             memcpy(&ref, block_and_ref + sizeof(freeblock), sizeof(ref));
 171             --ref;
 172             memcpy(block_and_ref + sizeof(freeblock), &ref, sizeof(ref));
 173             if (ref)
 174             {
 175                 if (bf_write(p->data_BFile[dst_type], freeblock, 0,
 176                               sizeof(block_and_ref), block_and_ref))
 177                 {
 178                     yaz_log(YLOG_FATAL|YLOG_ERRNO, "write in rec_del_single");
 179                     exit(1);
 180                 }
 181                 return;
 182             }
 183             first = 0;
 184         }
 185
 186         if (bf_write(p->data_BFile[dst_type], freeblock, 0, sizeof(freeblock),
 187                       &p->head.block_free[dst_type]))
 188         {
 189             yaz_log(YLOG_FATAL|YLOG_ERRNO, "write in rec_del_single");
 190             exit(1);
 191         }
 192         p->head.block_free[dst_type] = freeblock;
 193         memcpy(&freeblock, block_and_ref, sizeof(freeblock));
 194
 195         p->head.block_used[dst_type]--;
 196     }
 197     p->head.total_bytes -= entry.size;
 198 }
 199
 200 static void rec_delete_single(Records p, Record rec)
 201 {
 202     struct record_index_entry entry;
 203
 204     rec_release_blocks(p, rec_sysno_to_int(rec->sysno));
 205
 206     entry.next = p->head.index_free;
 207     entry.size = 0;
 208     p->head.index_free = rec_sysno_to_int(rec->sysno);
 209     write_indx(p, rec_sysno_to_int(rec->sysno), &entry, sizeof(entry));
 210 }
 211
 212 static void rec_write_tmp_buf(Records p, int size, SYSNO *sysnos)
 213 {
 214     struct record_index_entry entry;
 215     int no_written = 0;
 216     char *cptr = p->tmp_buf;
 217     zint block_prev = -1, block_free;
 218     int dst_type = 0;
 219     int i;
 220
 221     for (i = 1; i<REC_BLOCK_TYPES; i++)
 222         if (size >= p->head.block_move[i])
 223             dst_type = i;
 224     while (no_written < size)
 225     {
 226         block_free = p->head.block_free[dst_type];
 227         if (block_free)
 228         {
 229             if (bf_read(p->data_BFile[dst_type],
 230                          block_free, 0, sizeof(*p->head.block_free),
 231                          &p->head.block_free[dst_type]) != 1)
 232             {
 233                 yaz_log(YLOG_FATAL|YLOG_ERRNO, "read in %s at free block "
 234                          ZINT_FORMAT,
 235                          p->data_fname[dst_type], block_free);
 236                 exit(1);
 237             }
 238         }
 239         else
 240             block_free = p->head.block_last[dst_type]++;
 241         if (block_prev == -1)
 242         {
 243             entry.next = block_free*8 + dst_type;
 244             entry.size = size;
 245             p->head.total_bytes += size;
 246             while (*sysnos > 0)
 247             {
 248                 write_indx(p, *sysnos, &entry, sizeof(entry));
 249                 sysnos++;
 250             }
 251         }
 252         else
 253         {
 254             memcpy(cptr, &block_free, sizeof(block_free));
 255             bf_write(p->data_BFile[dst_type], block_prev, 0, 0, cptr);
 256             cptr = p->tmp_buf + no_written;
 257         }
 258         block_prev = block_free;
 259         no_written += (int)(p->head.block_size[dst_type]) - sizeof(zint);
 260         p->head.block_used[dst_type]++;
 261     }
 262     assert(block_prev != -1);
 263     block_free = 0;
 264     memcpy(cptr, &block_free, sizeof(block_free));
 265     bf_write(p->data_BFile[dst_type], block_prev, 0,
 266               sizeof(block_free) + (p->tmp_buf+size) - cptr, cptr);
 267 }
 268
 269 Records rec_open(BFiles bfs, int rw, int compression_method)
 270 {
 271     Records p;
 272     int i, r;
 273     int version;
 274
 275     p = (Records) xmalloc(sizeof(*p));
 276     p->compression_method = compression_method;
 277     p->rw = rw;
 278     p->tmp_size = 1024;
 279     p->tmp_buf = (char *) xmalloc(p->tmp_size);
 280     p->index_fname = "reci";
 281     p->index_BFile = bf_open(bfs, p->index_fname, RIDX_CHUNK, rw);
 282     if (p->index_BFile == NULL)
 283     {
 284         yaz_log(YLOG_FATAL|YLOG_ERRNO, "open %s", p->index_fname);
 285         exit(1);
 286     }
 287     r = bf_read(p->index_BFile, 0, 0, 0, p->tmp_buf);
 288     switch (r)
 289     {
 290     case 0:
 291         memcpy(p->head.magic, REC_HEAD_MAGIC, sizeof(p->head.magic));
 292         sprintf(p->head.version, "%3d", REC_VERSION);
 293         p->head.index_free = 0;
 294         p->head.index_last = 1;
 295         p->head.no_records = 0;
 296         p->head.total_bytes = 0;
 297         for (i = 0; i<REC_BLOCK_TYPES; i++)
 298         {
 299             p->head.block_free[i] = 0;
 300             p->head.block_last[i] = 1;
 301             p->head.block_used[i] = 0;
 302         }
 303         p->head.block_size[0] = 128;
 304         p->head.block_move[0] = 0;
 305         for (i = 1; i<REC_BLOCK_TYPES; i++)
 306         {
 307             p->head.block_size[i] = p->head.block_size[i-1] * 4;
 308             p->head.block_move[i] = p->head.block_size[i] * 24;
 309         }
 310         if (rw)
 311             rec_write_head(p);
 312         break;
 313     case 1:
 314         memcpy(&p->head, p->tmp_buf, sizeof(p->head));
 315         if (memcmp(p->head.magic, REC_HEAD_MAGIC, sizeof(p->head.magic)))
 316         {
 317             yaz_log(YLOG_FATAL, "file %s has bad format", p->index_fname);
 318             exit(1);
 319         }
 320         version = atoi(p->head.version);
 321         if (version != REC_VERSION)
 322         {
 323             yaz_log(YLOG_FATAL, "file %s is version %d, but version"
 324                   " %d is required", p->index_fname, version, REC_VERSION);
 325             exit(1);
 326         }
 327         break;
 328     }
 329     for (i = 0; i<REC_BLOCK_TYPES; i++)
 330     {
 331         char str[80];
 332         sprintf(str, "recd%c", i + 'A');
 333         p->data_fname[i] = (char *) xmalloc(strlen(str)+1);
 334         strcpy(p->data_fname[i], str);
 335         p->data_BFile[i] = NULL;
 336     }
 337     for (i = 0; i<REC_BLOCK_TYPES; i++)
 338     {
 339         if (!(p->data_BFile[i] = bf_open(bfs, p->data_fname[i],
 340                                          (int) (p->head.block_size[i]),
 341                                          rw)))
 342         {
 343             yaz_log(YLOG_FATAL|YLOG_ERRNO, "bf_open %s", p->data_fname[i]);
 344             exit(1);
 345         }
 346     }
 347     p->cache_max = 400;
 348     p->cache_cur = 0;
 349     p->record_cache = (struct record_cache_entry *)
 350         xmalloc(sizeof(*p->record_cache)*p->cache_max);
 351     zebra_mutex_init(&p->mutex);
 352     return p;
 353 }
 354
 355 static void rec_encode_unsigned(unsigned n, unsigned char *buf, int *len)
 356 {
 357     (*len) = 0;
 358     while (n > 127)
 359     {
 360         buf[*len] = 128 + (n & 127);
 361         n = n >> 7;
 362         (*len)++;
 363     }
 364     buf[*len] = n;
 365     (*len)++;
 366 }
 367
 368 static void rec_decode_unsigned(unsigned *np, unsigned char *buf, int *len)
 369 {
 370     unsigned n = 0;
 371     unsigned w = 1;
 372     (*len) = 0;
 373
 374     while (buf[*len] > 127)
 375     {
 376         n += w*(buf[*len] & 127);
 377         w = w << 7;
 378         (*len)++;
 379     }
 380     n += w * buf[*len];
 381     (*len)++;
 382     *np = n;
 383 }
 384
 385 static void rec_encode_zint(zint n, unsigned char *buf, int *len)
 386 {
 387     (*len) = 0;
 388     while (n > 127)
 389     {
 390         buf[*len] = (unsigned) (128 + (n & 127));
 391         n = n >> 7;
 392         (*len)++;
 393     }
 394     buf[*len] = (unsigned) n;
 395     (*len)++;
 396 }
 397
 398 static void rec_decode_zint(zint *np, unsigned char *buf, int *len)
 399 {
 400     zint  n = 0;
 401     zint w = 1;
 402     (*len) = 0;
 403
 404     while (buf[*len] > 127)
 405     {
 406         n += w*(buf[*len] & 127);
 407         w = w << 7;
 408         (*len)++;
 409     }
 410     n += w * buf[*len];
 411     (*len)++;
 412     *np = n;
 413 }
 414
 415 static void rec_cache_flush_block1(Records p, Record rec, Record last_rec,
 416                                    char **out_buf, int *out_size,
 417                                    int *out_offset)
 418 {
 419     int i;
 420     int len;
 421
 422     for (i = 0; i<REC_NO_INFO; i++)
 423     {
 424         if (*out_offset + (int) rec->size[i] + 20 > *out_size)
 425         {
 426             int new_size = *out_offset + rec->size[i] + 65536;
 427             char *np = (char *) xmalloc(new_size);
 428             if (*out_offset)
 429                 memcpy(np, *out_buf, *out_offset);
 430             xfree(*out_buf);
 431             *out_size = new_size;
 432             *out_buf = np;
 433         }
 434         if (i == 0)
 435         {
 436             rec_encode_zint(rec_sysno_to_int(rec->sysno),
 437                             (unsigned char *) *out_buf + *out_offset, &len);
 438             (*out_offset) += len;
 439         }
 440         if (rec->size[i] == 0)
 441         {
 442             rec_encode_unsigned(1, (unsigned char *) *out_buf + *out_offset,
 443                                 &len);
 444             (*out_offset) += len;
 445         }
 446         else if (last_rec && rec->size[i] == last_rec->size[i] &&
 447                  !memcmp(rec->info[i], last_rec->info[i], rec->size[i]))
 448         {
 449             rec_encode_unsigned(0, (unsigned char *) *out_buf + *out_offset,
 450                                 &len);
 451             (*out_offset) += len;
 452         }
 453         else
 454         {
 455             rec_encode_unsigned(rec->size[i]+1,
 456                                 (unsigned char *) *out_buf + *out_offset,
 457                                 &len);
 458             (*out_offset) += len;
 459             memcpy(*out_buf + *out_offset, rec->info[i], rec->size[i]);
 460             (*out_offset) += rec->size[i];
 461         }
 462     }
 463 }
 464
 465 static void rec_write_multiple(Records p, int saveCount)
 466 {
 467     int i;
 468     short ref_count = 0;
 469     char compression_method;
 470     Record last_rec = 0;
 471     int out_size = 1000;
 472     int out_offset = 0;
 473     char *out_buf = (char *) xmalloc(out_size);
 474     SYSNO *sysnos = (SYSNO *) xmalloc(sizeof(*sysnos) * (p->cache_cur + 1));
 475     SYSNO *sysnop = sysnos;
 476
 477     for (i = 0; i<p->cache_cur - saveCount; i++)
 478     {
 479         struct record_cache_entry *e = p->record_cache + i;
 480         switch (e->flag)
 481         {
 482         case recordFlagNew:
 483             rec_cache_flush_block1(p, e->rec, last_rec, &out_buf,
 484                                     &out_size, &out_offset);
 485             *sysnop++ = rec_sysno_to_int(e->rec->sysno);
 486             ref_count++;
 487             e->flag = recordFlagNop;
 488             last_rec = e->rec;
 489             break;
 490         case recordFlagWrite:
 491             rec_release_blocks(p, rec_sysno_to_int(e->rec->sysno));
 492             rec_cache_flush_block1(p, e->rec, last_rec, &out_buf,
 493                                     &out_size, &out_offset);
 494             *sysnop++ = rec_sysno_to_int(e->rec->sysno);
 495             ref_count++;
 496             e->flag = recordFlagNop;
 497             last_rec = e->rec;
 498             break;
 499         case recordFlagDelete:
 500             rec_delete_single(p, e->rec);
 501             e->flag = recordFlagNop;
 502             break;
 503         default:
 504             break;
 505         }
 506     }
 507
 508     *sysnop = -1;
 509     if (ref_count)
 510     {
 511         unsigned int csize = 0;  /* indicate compression "not performed yet" */
 512         compression_method = p->compression_method;
 513         switch (compression_method)
 514         {
 515         case REC_COMPRESS_BZIP2:
 516 #if HAVE_BZLIB_H
 517             csize = out_offset + (out_offset >> 6) + 620;
 518             rec_tmp_expand(p, csize);
 519 #ifdef BZ_CONFIG_ERROR
 520             i = BZ2_bzBuffToBuffCompress
 521 #else
 522             i = bzBuffToBuffCompress
 523 #endif
 524                                     (p->tmp_buf+sizeof(zint)+sizeof(short)+
 525                                       sizeof(char),
 526                                       &csize, out_buf, out_offset, 1, 0, 30);
 527             if (i != BZ_OK)
 528             {
 529                 yaz_log(YLOG_WARN, "bzBuffToBuffCompress error code=%d", i);
 530                 csize = 0;
 531             }
 532             yaz_log(YLOG_LOG, "compress %4d %5d %5d", ref_count, out_offset,
 533                   csize);
 534 #endif
 535             break;
 536         case REC_COMPRESS_NONE:
 537             break;
 538         }
 539         if (!csize)
 540         {
 541             /* either no compression or compression not supported ... */
 542             csize = out_offset;
 543             rec_tmp_expand(p, csize);
 544             memcpy(p->tmp_buf + sizeof(zint) + sizeof(short) + sizeof(char),
 545                     out_buf, out_offset);
 546             csize = out_offset;
 547             compression_method = REC_COMPRESS_NONE;
 548         }
 549         memcpy(p->tmp_buf + sizeof(zint), &ref_count, sizeof(ref_count));
 550         memcpy(p->tmp_buf + sizeof(zint)+sizeof(short),
 551                 &compression_method, sizeof(compression_method));
 552
 553         /* -------- compression */
 554         rec_write_tmp_buf(p, csize + sizeof(short) + sizeof(char), sysnos);
 555     }
 556     xfree(out_buf);
 557     xfree(sysnos);
 558 }
 559
 560 static void rec_cache_flush(Records p, int saveCount)
 561 {
 562     int i, j;
 563
 564     if (saveCount >= p->cache_cur)
 565         saveCount = 0;
 566
 567     rec_write_multiple(p, saveCount);
 568
 569     for (i = 0; i<p->cache_cur - saveCount; i++)
 570     {
 571         struct record_cache_entry *e = p->record_cache + i;
 572         rec_rm(&e->rec);
 573     }
 574     /* i still being used ... */
 575     for (j = 0; j<saveCount; j++, i++)
 576         memcpy(p->record_cache+j, p->record_cache+i,
 577                 sizeof(*p->record_cache));
 578     p->cache_cur = saveCount;
 579 }
 580
 581 static Record *rec_cache_lookup(Records p, SYSNO sysno,
 582                                 enum recordCacheFlag flag)
 583 {
 584     int i;
 585     for (i = 0; i<p->cache_cur; i++)
 586     {
 587         struct record_cache_entry *e = p->record_cache + i;
 588         if (e->rec->sysno == sysno)
 589         {
 590             if (flag != recordFlagNop && e->flag == recordFlagNop)
 591                 e->flag = flag;
 592             return &e->rec;
 593         }
 594     }
 595     return NULL;
 596 }
 597
 598 static void rec_cache_insert(Records p, Record rec, enum recordCacheFlag flag)
 599 {
 600     struct record_cache_entry *e;
 601
 602     if (p->cache_cur == p->cache_max)
 603         rec_cache_flush(p, 1);
 604     else if (p->cache_cur > 0)
 605     {
 606         int i, j;
 607         int used = 0;
 608         for (i = 0; i<p->cache_cur; i++)
 609         {
 610             Record r = (p->record_cache + i)->rec;
 611             for (j = 0; j<REC_NO_INFO; j++)
 612                 used += r->size[j];
 613         }
 614         if (used > 90000)
 615             rec_cache_flush(p, 1);
 616     }
 617     assert(p->cache_cur < p->cache_max);
 618
 619     e = p->record_cache + (p->cache_cur)++;
 620     e->flag = flag;
 621     e->rec = rec_cp(rec);
 622 }
 623
 624 void rec_close(Records *pp)
 625 {
 626     Records p = *pp;
 627     int i;
 628
 629     assert(p);
 630
 631     zebra_mutex_destroy(&p->mutex);
 632     rec_cache_flush(p, 0);
 633     xfree(p->record_cache);
 634
 635     if (p->rw)
 636         rec_write_head(p);
 637
 638     if (p->index_BFile)
 639         bf_close(p->index_BFile);
 640
 641     for (i = 0; i<REC_BLOCK_TYPES; i++)
 642     {
 643         if (p->data_BFile[i])
 644             bf_close(p->data_BFile[i]);
 645         xfree(p->data_fname[i]);
 646     }
 647     xfree(p->tmp_buf);
 648     xfree(p);
 649     *pp = NULL;
 650 }
 651
 652 static Record rec_get_int(Records p, SYSNO sysno)
 653 {
 654     int i, in_size, r;
 655     Record rec, *recp;
 656     struct record_index_entry entry;
 657     zint freeblock;
 658     int dst_type;
 659     char *nptr, *cptr;
 660     char *in_buf = 0;
 661     char *bz_buf = 0;
 662 #if HAVE_BZLIB_H
 663     unsigned int bz_size;
 664 #endif
 665     char compression_method;
 666
 667     assert(sysno > 0);
 668     assert(p);
 669
 670     if ((recp = rec_cache_lookup(p, sysno, recordFlagNop)))
 671         return rec_cp(*recp);
 672
 673     if (read_indx(p, rec_sysno_to_int(sysno), &entry, sizeof(entry), 1) < 1)
 674         return NULL;       /* record is not there! */
 675
 676     if (!entry.size)
 677         return NULL;       /* record is deleted */
 678
 679     dst_type = (int) (entry.next & 7);
 680     assert(dst_type < REC_BLOCK_TYPES);
 681     freeblock = entry.next / 8;
 682
 683     assert(freeblock > 0);
 684
 685     rec_tmp_expand(p, entry.size);
 686
 687     cptr = p->tmp_buf;
 688     r = bf_read(p->data_BFile[dst_type], freeblock, 0, 0, cptr);
 689     if (r < 0)
 690         return 0;
 691     memcpy(&freeblock, cptr, sizeof(freeblock));
 692
 693     while (freeblock)
 694     {
 695         zint tmp;
 696
 697         cptr += p->head.block_size[dst_type] - sizeof(freeblock);
 698
 699         memcpy(&tmp, cptr, sizeof(tmp));
 700         r = bf_read(p->data_BFile[dst_type], freeblock, 0, 0, cptr);
 701         if (r < 0)
 702             return 0;
 703         memcpy(&freeblock, cptr, sizeof(freeblock));
 704         memcpy(cptr, &tmp, sizeof(tmp));
 705     }
 706
 707     rec = (Record) xmalloc(sizeof(*rec));
 708     rec->sysno = sysno;
 709     memcpy(&compression_method, p->tmp_buf + sizeof(zint) + sizeof(short),
 710             sizeof(compression_method));
 711     in_buf = p->tmp_buf + sizeof(zint) + sizeof(short) + sizeof(char);
 712     in_size = entry.size - sizeof(short) - sizeof(char);
 713     switch (compression_method)
 714     {
 715     case REC_COMPRESS_BZIP2:
 716 #if HAVE_BZLIB_H
 717         bz_size = entry.size * 20 + 100;
 718         while (1)
 719         {
 720             bz_buf = (char *) xmalloc(bz_size);
 721 #ifdef BZ_CONFIG_ERROR
 722             i = BZ2_bzBuffToBuffDecompress
 723 #else
 724             i = bzBuffToBuffDecompress
 725 #endif
 726                 (bz_buf, &bz_size, in_buf, in_size, 0, 0);
 727             yaz_log(YLOG_LOG, "decompress %5d %5d", in_size, bz_size);
 728             if (i == BZ_OK)
 729                 break;
 730             yaz_log(YLOG_LOG, "failed");
 731             xfree(bz_buf);
 732             bz_size *= 2;
 733         }
 734         in_buf = bz_buf;
 735         in_size = bz_size;
 736 #else
 737         yaz_log(YLOG_FATAL, "cannot decompress record(s) in BZIP2 format");
 738         exit(1);
 739 #endif
 740         break;
 741     case REC_COMPRESS_NONE:
 742         break;
 743     }
 744     for (i = 0; i<REC_NO_INFO; i++)
 745         rec->info[i] = 0;
 746
 747     nptr = in_buf;                /* skip ref count */
 748     while (nptr < in_buf + in_size)
 749     {
 750         zint this_sysno;
 751         int len;
 752         rec_decode_zint(&this_sysno, (unsigned char *) nptr, &len);
 753         nptr += len;
 754
 755         for (i = 0; i < REC_NO_INFO; i++)
 756         {
 757             unsigned int this_size;
 758             rec_decode_unsigned(&this_size, (unsigned char *) nptr, &len);
 759             nptr += len;
 760
 761             if (this_size == 0)
 762                 continue;
 763             rec->size[i] = this_size-1;
 764
 765             if (rec->size[i])
 766             {
 767                 rec->info[i] = nptr;
 768                 nptr += rec->size[i];
 769             }
 770             else
 771                 rec->info[i] = NULL;
 772         }
 773         if (this_sysno == rec_sysno_to_int(sysno))
 774             break;
 775     }
 776     for (i = 0; i<REC_NO_INFO; i++)
 777     {
 778         if (rec->info[i] && rec->size[i])
 779         {
 780             char *np = xmalloc(rec->size[i]+1);
 781             memcpy(np, rec->info[i], rec->size[i]);
 782             np[rec->size[i]] = '\0';
 783             rec->info[i] = np;
 784         }
 785         else
 786         {
 787             assert(rec->info[i] == 0);
 788             assert(rec->size[i] == 0);
 789         }
 790     }
 791     xfree(bz_buf);
 792     rec_cache_insert(p, rec, recordFlagNop);
 793     return rec;
 794 }
 795
 796 Record rec_get(Records p, SYSNO sysno)
 797 {
 798     Record rec;
 799     zebra_mutex_lock(&p->mutex);
 800
 801     rec = rec_get_int(p, sysno);
 802     zebra_mutex_unlock(&p->mutex);
 803     return rec;
 804 }
 805
 806 Record rec_get_root(Records p)
 807 {
 808     return rec_get(p, rec_sysno_to_ext(1));
 809 }
 810
 811 static Record rec_new_int(Records p)
 812 {
 813     int i;
 814     SYSNO sysno;
 815     Record rec;
 816
 817     assert(p);
 818     rec = (Record) xmalloc(sizeof(*rec));
 819     if (1 || p->head.index_free == 0)
 820         sysno = (p->head.index_last)++;
 821     else
 822     {
 823         struct record_index_entry entry;
 824
 825         read_indx(p, p->head.index_free, &entry, sizeof(entry), 0);
 826         sysno = p->head.index_free;
 827         p->head.index_free = entry.next;
 828     }
 829     (p->head.no_records)++;
 830     rec->sysno = rec_sysno_to_ext(sysno);
 831     for (i = 0; i < REC_NO_INFO; i++)
 832     {
 833         rec->info[i] = NULL;
 834         rec->size[i] = 0;
 835     }
 836     rec_cache_insert(p, rec, recordFlagNew);
 837     return rec;
 838 }
 839
 840 Record rec_new(Records p)
 841 {
 842     Record rec;
 843     zebra_mutex_lock(&p->mutex);
 844
 845     rec = rec_new_int(p);
 846     zebra_mutex_unlock(&p->mutex);
 847     return rec;
 848 }
 849
 850 void rec_del(Records p, Record *recpp)
 851 {
 852     Record *recp;
 853
 854     zebra_mutex_lock(&p->mutex);
 855     (p->head.no_records)--;
 856     if ((recp = rec_cache_lookup(p, (*recpp)->sysno, recordFlagDelete)))
 857     {
 858         rec_rm(recp);
 859         *recp = *recpp;
 860     }
 861     else
 862     {
 863         rec_cache_insert(p, *recpp, recordFlagDelete);
 864         rec_rm(recpp);
 865     }
 866     zebra_mutex_unlock(&p->mutex);
 867     *recpp = NULL;
 868 }
 869
 870 void rec_put(Records p, Record *recpp)
 871 {
 872     Record *recp;
 873
 874     zebra_mutex_lock(&p->mutex);
 875     if ((recp = rec_cache_lookup(p, (*recpp)->sysno, recordFlagWrite)))
 876     {
 877         rec_rm(recp);
 878         *recp = *recpp;
 879     }
 880     else
 881     {
 882         rec_cache_insert(p, *recpp, recordFlagWrite);
 883         rec_rm(recpp);
 884     }
 885     zebra_mutex_unlock(&p->mutex);
 886     *recpp = NULL;
 887 }
 888
 889 void rec_rm(Record *recpp)
 890 {
 891     int i;
 892
 893     if (!*recpp)
 894         return ;
 895     for (i = 0; i < REC_NO_INFO; i++)
 896         xfree((*recpp)->info[i]);
 897     xfree(*recpp);
 898     *recpp = NULL;
 899 }
 900
 901 Record rec_cp(Record rec)
 902 {
 903     Record n;
 904     int i;
 905
 906     n = (Record) xmalloc(sizeof(*n));
 907     n->sysno = rec->sysno;
 908     for (i = 0; i < REC_NO_INFO; i++)
 909         if (!rec->info[i])
 910         {
 911             n->info[i] = NULL;
 912             n->size[i] = 0;
 913         }
 914         else
 915         {
 916             n->size[i] = rec->size[i];
 917             n->info[i] = (char *) xmalloc(rec->size[i]);
 918             memcpy(n->info[i], rec->info[i], rec->size[i]);
 919         }
 920     return n;
 921 }
 922
 923
 924 char *rec_strdup(const char *s, size_t *len)
 925 {
 926     char *p;
 927
 928     if (!s)
 929     {
 930         *len = 0;
 931         return NULL;
 932     }
 933     *len = strlen(s)+1;
 934     p = (char *) xmalloc(*len);
 935     strcpy(p, s);
 936     return p;
 937 }
 938