On Unix, zebra/z'mbol uses automake.

[idzebra-moved-to-github.git] / index / recindex.c

diff --git a/index/recindex.c b/index/recindex.c
index 25a02f3..29006d7 100644 (file)
--- a/index/recindex.c
+++ b/index/recindex.c
@@ -4,7 +4,16 @@
  * Sebastian Hammer, Adam Dickmeiss
  *
  * $Log: recindex.c,v $
- * Revision 1.26  1999-07-06 13:34:57  adam
+ * Revision 1.29  2000-04-05 09:49:35  adam
+ * On Unix, zebra/z'mbol uses automake.
+ *
+ * Revision 1.28  1999/12/08 22:44:45  adam
+ * Zebra/Z'mbol dependencies added.
+ *
+ * Revision 1.27  1999/10/29 10:02:33  adam
+ * Fixed decompression buffer overflow.
+ *
+ * Revision 1.26  1999/07/06 13:34:57  adam
  * Fixed bug (introduced by previous commit).
  *
  * Revision 1.25  1999/07/06 12:28:04  adam
@@ -390,6 +399,7 @@ Records rec_open (BFiles bfs, int rw, int compression_method)
     p->cache_cur = 0;
     p->record_cache = (struct record_cache_entry *)
        xmalloc (sizeof(*p->record_cache)*p->cache_max);
+    zebra_mutex_init (&p->mutex);
     return p;
 }
 
@@ -629,6 +639,7 @@ void rec_close (Records *pp)
 
     assert (p);
 
+    zebra_mutex_destroy (&p->mutex);
     rec_cache_flush (p, 0);
     xfree (p->record_cache);
 
@@ -649,10 +660,9 @@ void rec_close (Records *pp)
     *pp = NULL;
 }
 
-
-Record rec_get (Records p, int sysno)
+static Record rec_get_int (Records p, int sysno)
 {
-    int i, in_size;
+    int i, in_size, r;
     Record rec, *recp;
     struct record_index_entry entry;
     int freeblock, dst_type;
@@ -668,7 +678,7 @@ Record rec_get (Records p, int sysno)
     if ((recp = rec_cache_lookup (p, sysno, recordFlagNop)))
         return rec_cp (*recp);
 
-    if (!read_indx (p, sysno, &entry, sizeof(entry), 1))
+    if (read_indx (p, sysno, &entry, sizeof(entry), 1) < 1)
         return NULL;       /* record is not there! */
 
     if (!entry.size)
@@ -680,11 +690,12 @@ Record rec_get (Records p, int sysno)
 
     assert (freeblock > 0);
     
-    rec = (Record) xmalloc (sizeof(*rec));
     rec_tmp_expand (p, entry.size);
 
     cptr = p->tmp_buf;
-    bf_read (p->data_BFile[dst_type], freeblock, 0, 0, cptr);
+    r = bf_read (p->data_BFile[dst_type], freeblock, 0, 0, cptr);
+    if (r < 0)
+       return 0;
     memcpy (&freeblock, cptr, sizeof(freeblock));
 
     while (freeblock)
@@ -694,11 +705,14 @@ Record rec_get (Records p, int sysno)
         cptr += p->head.block_size[dst_type] - sizeof(freeblock);
         
         memcpy (&tmp, cptr, sizeof(tmp));
-        bf_read (p->data_BFile[dst_type], freeblock, 0, 0, cptr);
+        r = bf_read (p->data_BFile[dst_type], freeblock, 0, 0, cptr);
+       if (r < 0)
+           return 0;
         memcpy (&freeblock, cptr, sizeof(freeblock));
         memcpy (cptr, &tmp, sizeof(tmp));
     }
 
+    rec = (Record) xmalloc (sizeof(*rec));
     rec->sysno = sysno;
     memcpy (&compression_method, p->tmp_buf + sizeof(int) + sizeof(short),
            sizeof(compression_method));
@@ -708,14 +722,17 @@ Record rec_get (Records p, int sysno)
     {
     case REC_COMPRESS_BZIP2:
 #if HAVE_BZLIB_H
-       bz_size = entry.size * 30+100;
-       bz_buf = (char *) xmalloc (bz_size);
-       i = bzBuffToBuffDecompress (bz_buf, &bz_size, in_buf, in_size, 0, 0);
-       logf (LOG_LOG, "decompress %5d %5d", in_size, bz_size);
-       if (i != BZ_OK)
+       bz_size = entry.size * 20 + 100;
+       while (1)
        {
-           logf (LOG_FATAL, "bzBuffToBuffDecompress error code=%d", i);
-           exit (1);
+           bz_buf = (char *) xmalloc (bz_size);
+           i = bzBuffToBuffDecompress (bz_buf, &bz_size, in_buf, in_size, 0, 0);
+           logf (LOG_LOG, "decompress %5d %5d", in_size, bz_size);
+           if (i == BZ_OK)
+               break;
+           logf (LOG_LOG, "failed");
+           xfree (bz_buf);
+            bz_size *= 2;
        }
        in_buf = bz_buf;
        in_size = bz_size;
@@ -778,7 +795,17 @@ Record rec_get (Records p, int sysno)
     return rec;
 }
 
-Record rec_new (Records p)
+Record rec_get (Records p, int sysno)
+{
+    Record rec;
+    zebra_mutex_lock (&p->mutex);
+
+    rec = rec_get_int (p, sysno);
+    zebra_mutex_unlock (&p->mutex);
+    return rec;
+}
+
+static Record rec_new_int (Records p)
 {
     int sysno, i;
     Record rec;
@@ -795,6 +822,14 @@ Record rec_new (Records p)
         sysno = p->head.index_free;
         p->head.index_free = entry.next;
     }
+#if ZMBOL
+#else
+    if (sysno > 100000)
+    {
+        logf (LOG_FATAL, "100,000 record limit reached");
+        exit (1);
+    }
+#endif
     (p->head.no_records)++;
     rec->sysno = sysno;
     for (i = 0; i < REC_NO_INFO; i++)
@@ -806,10 +841,21 @@ Record rec_new (Records p)
     return rec;
 }
 
+Record rec_new (Records p)
+{
+    Record rec;
+    zebra_mutex_lock (&p->mutex);
+
+    rec = rec_new_int (p);
+    zebra_mutex_unlock (&p->mutex);
+    return rec;
+}
+
 void rec_del (Records p, Record *recpp)
 {
     Record *recp;
 
+    zebra_mutex_lock (&p->mutex);
     (p->head.no_records)--;
     if ((recp = rec_cache_lookup (p, (*recpp)->sysno, recordFlagDelete)))
     {
@@ -821,6 +867,7 @@ void rec_del (Records p, Record *recpp)
         rec_cache_insert (p, *recpp, recordFlagDelete);
         rec_rm (recpp);
     }
+    zebra_mutex_unlock (&p->mutex);
     *recpp = NULL;
 }
 
@@ -828,6 +875,7 @@ void rec_put (Records p, Record *recpp)
 {
     Record *recp;
 
+    zebra_mutex_lock (&p->mutex);
     if ((recp = rec_cache_lookup (p, (*recpp)->sysno, recordFlagWrite)))
     {
         rec_rm (recp);
@@ -838,6 +886,7 @@ void rec_put (Records p, Record *recpp)
         rec_cache_insert (p, *recpp, recordFlagWrite);
         rec_rm (recpp);
     }
+    zebra_mutex_unlock (&p->mutex);
     *recpp = NULL;
 }