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