X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;f=index%2Frecindex.c;h=95a4474932a92d65644da4c551cf780c6b61f53a;hb=c33ea56e3771c3b80ba66ef8fda3a09cad171ebb;hp=793898b794e3ff4f5abfafd74a1db69a46f14724;hpb=6c9fcd3b5d3108702fa1ffc92dab4ab6060f9a19;p=idzebra-moved-to-github.git diff --git a/index/recindex.c b/index/recindex.c index 793898b..95a4474 100644 --- a/index/recindex.c +++ b/index/recindex.c @@ -1,5 +1,5 @@ -/* $Id: recindex.c,v 1.41 2005-01-15 19:38:26 adam Exp $ - Copyright (C) 1995-2005 +/* $Id: recindex.c,v 1.51 2006-08-14 10:40:15 adam Exp $ + Copyright (C) 1995-2006 Index Data ApS This file is part of the Zebra server. @@ -15,9 +15,9 @@ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License -along with Zebra; see the file LICENSE.zebra. If not, write to the -Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA -02111-1307, USA. +along with this program; if not, write to the Free Software +Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ #define RIDX_CHUNK 128 @@ -38,69 +38,96 @@ Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA * length = 0 if same as previous */ #include +#include #include #include +#include #include "recindxp.h" #if HAVE_BZLIB_H #include #endif -static void rec_write_head (Records p) + +/* Modify argument to if below: 1=normal, 0=sysno testing */ +#if 1 +/* If this is used sysno are not converted (no testing) */ +#define FAKE_OFFSET 0 +#define USUAL_RANGE 6000000000LL + +#else +/* Use a fake > 2^32 offset so we can test for proper 64-bit handling */ +#define FAKE_OFFSET 6000000000LL +#define USUAL_RANGE 2000000000LL +#endif + +static SYSNO rec_sysno_to_ext(SYSNO sysno) +{ + assert(sysno >= 0 && sysno <= USUAL_RANGE); + return sysno + FAKE_OFFSET; +} + +SYSNO rec_sysno_to_int(SYSNO sysno) +{ + assert(sysno >= FAKE_OFFSET && sysno <= FAKE_OFFSET + USUAL_RANGE); + return sysno - FAKE_OFFSET; +} + +static ZEBRA_RES rec_write_head(Records p) { int r; - assert (p); - assert (p->index_BFile); + assert(p); + assert(p->index_BFile); - r = bf_write (p->index_BFile, 0, 0, sizeof(p->head), &p->head); + r = bf_write(p->index_BFile, 0, 0, sizeof(p->head), &p->head); if (r) { - yaz_log (YLOG_FATAL|YLOG_ERRNO, "write head of %s", p->index_fname); - exit (1); + yaz_log(YLOG_FATAL|YLOG_ERRNO, "write head of %s", p->index_fname); + return ZEBRA_FAIL; } + return ZEBRA_OK; } -static void rec_tmp_expand (Records p, int size) +static void rec_tmp_expand(Records p, int size) { if (p->tmp_size < size + 2048 || p->tmp_size < p->head.block_size[REC_BLOCK_TYPES-1]*2) { - xfree (p->tmp_buf); + xfree(p->tmp_buf); p->tmp_size = size + (int) (p->head.block_size[REC_BLOCK_TYPES-1])*2 + 2048; - p->tmp_buf = (char *) xmalloc (p->tmp_size); + p->tmp_buf = (char *) xmalloc(p->tmp_size); } } -static int read_indx (Records p, SYSNO sysno, void *buf, int itemsize, +static int read_indx(Records p, SYSNO sysno, void *buf, int itemsize, int ignoreError) { int r; zint pos = (sysno-1)*itemsize; - int off = (int) (pos%RIDX_CHUNK); + int off = CAST_ZINT_TO_INT(pos%RIDX_CHUNK); int sz1 = RIDX_CHUNK - off; /* sz1 is size of buffer to read.. */ if (sz1 > itemsize) sz1 = itemsize; /* no more than itemsize bytes */ - r = bf_read (p->index_BFile, 1+pos/RIDX_CHUNK, off, sz1, buf); + r = bf_read(p->index_BFile, 1+pos/RIDX_CHUNK, off, sz1, buf); if (r == 1 && sz1 < itemsize) /* boundary? - must read second part */ - r = bf_read (p->index_BFile, 2+pos/RIDX_CHUNK, 0, itemsize - sz1, + r = bf_read(p->index_BFile, 2+pos/RIDX_CHUNK, 0, itemsize - sz1, (char*) buf + sz1); if (r != 1 && !ignoreError) { - yaz_log (YLOG_FATAL|YLOG_ERRNO, "read in %s at pos %ld", - p->index_fname, (long) pos); - exit (1); + yaz_log(YLOG_FATAL|YLOG_ERRNO, "read in %s at pos %ld", + p->index_fname, (long) pos); } return r; } -static void write_indx (Records p, SYSNO sysno, void *buf, int itemsize) +static void write_indx(Records p, SYSNO sysno, void *buf, int itemsize) { zint pos = (sysno-1)*itemsize; - int off = (int) (pos%RIDX_CHUNK); + int off = CAST_ZINT_TO_INT(pos%RIDX_CHUNK); int sz1 = RIDX_CHUNK - off; /* sz1 is size of buffer to read.. */ if (sz1 > itemsize) @@ -112,7 +139,7 @@ static void write_indx (Records p, SYSNO sysno, void *buf, int itemsize) (char*) buf + sz1); } -static void rec_release_blocks (Records p, SYSNO sysno) +static ZEBRA_RES rec_release_blocks(Records p, SYSNO sysno) { struct record_index_entry entry; zint freeblock; @@ -120,69 +147,72 @@ static void rec_release_blocks (Records p, SYSNO sysno) int dst_type; int first = 1; - if (read_indx (p, sysno, &entry, sizeof(entry), 1) != 1) - return ; + if (read_indx(p, sysno, &entry, sizeof(entry), 1) != 1) + return ZEBRA_FAIL; freeblock = entry.next; - assert (freeblock > 0); - dst_type = (int) (freeblock & 7); - assert (dst_type < REC_BLOCK_TYPES); + assert(freeblock > 0); + dst_type = CAST_ZINT_TO_INT(freeblock & 7); + assert(dst_type < REC_BLOCK_TYPES); freeblock = freeblock / 8; while (freeblock) { - if (bf_read (p->data_BFile[dst_type], freeblock, 0, + if (bf_read(p->data_BFile[dst_type], freeblock, 0, first ? sizeof(block_and_ref) : sizeof(zint), block_and_ref) != 1) { - yaz_log (YLOG_FATAL|YLOG_ERRNO, "read in rec_del_single"); - exit (1); + yaz_log(YLOG_FATAL|YLOG_ERRNO, "read in rec_del_single"); + return ZEBRA_FAIL; } if (first) { short ref; - memcpy (&ref, block_and_ref + sizeof(freeblock), sizeof(ref)); + memcpy(&ref, block_and_ref + sizeof(freeblock), sizeof(ref)); --ref; - memcpy (block_and_ref + sizeof(freeblock), &ref, sizeof(ref)); + memcpy(block_and_ref + sizeof(freeblock), &ref, sizeof(ref)); if (ref) { - if (bf_write (p->data_BFile[dst_type], freeblock, 0, + if (bf_write(p->data_BFile[dst_type], freeblock, 0, sizeof(block_and_ref), block_and_ref)) { - yaz_log (YLOG_FATAL|YLOG_ERRNO, "write in rec_del_single"); - exit (1); + yaz_log(YLOG_FATAL|YLOG_ERRNO, "write in rec_del_single"); + return ZEBRA_FAIL; } - return; + return ZEBRA_OK; } first = 0; } - if (bf_write (p->data_BFile[dst_type], freeblock, 0, sizeof(freeblock), + if (bf_write(p->data_BFile[dst_type], freeblock, 0, sizeof(freeblock), &p->head.block_free[dst_type])) { - yaz_log (YLOG_FATAL|YLOG_ERRNO, "write in rec_del_single"); - exit (1); + yaz_log(YLOG_FATAL|YLOG_ERRNO, "write in rec_del_single"); + return ZEBRA_FAIL; } p->head.block_free[dst_type] = freeblock; - memcpy (&freeblock, block_and_ref, sizeof(freeblock)); + memcpy(&freeblock, block_and_ref, sizeof(freeblock)); p->head.block_used[dst_type]--; } p->head.total_bytes -= entry.size; + return ZEBRA_OK; } -static void rec_delete_single (Records p, Record rec) +static ZEBRA_RES rec_delete_single(Records p, Record rec) { struct record_index_entry entry; - rec_release_blocks (p, rec->sysno); + if (rec_release_blocks(p, rec_sysno_to_int(rec->sysno)) != ZEBRA_OK) + return ZEBRA_FAIL; entry.next = p->head.index_free; entry.size = 0; - p->head.index_free = rec->sysno; - write_indx (p, rec->sysno, &entry, sizeof(entry)); + p->head.index_free = rec_sysno_to_int(rec->sysno); + write_indx(p, rec_sysno_to_int(rec->sysno), &entry, sizeof(entry)); + return ZEBRA_OK; } -static void rec_write_tmp_buf (Records p, int size, SYSNO *sysnos) +static ZEBRA_RES rec_write_tmp_buf(Records p, int size, SYSNO *sysnos) { struct record_index_entry entry; int no_written = 0; @@ -199,13 +229,14 @@ static void rec_write_tmp_buf (Records p, int size, SYSNO *sysnos) block_free = p->head.block_free[dst_type]; if (block_free) { - if (bf_read (p->data_BFile[dst_type], + if (bf_read(p->data_BFile[dst_type], block_free, 0, sizeof(*p->head.block_free), &p->head.block_free[dst_type]) != 1) { - yaz_log (YLOG_FATAL|YLOG_ERRNO, "read in %s at free block " ZINT_FORMAT, - p->data_fname[dst_type], block_free); - exit (1); + yaz_log(YLOG_FATAL|YLOG_ERRNO, "read in %s at free block " + ZINT_FORMAT, + p->data_fname[dst_type], block_free); + return ZEBRA_FAIL; } } else @@ -217,51 +248,55 @@ static void rec_write_tmp_buf (Records p, int size, SYSNO *sysnos) p->head.total_bytes += size; while (*sysnos > 0) { - write_indx (p, *sysnos, &entry, sizeof(entry)); + write_indx(p, *sysnos, &entry, sizeof(entry)); sysnos++; } } else { - memcpy (cptr, &block_free, sizeof(block_free)); - bf_write (p->data_BFile[dst_type], block_prev, 0, 0, cptr); + memcpy(cptr, &block_free, sizeof(block_free)); + bf_write(p->data_BFile[dst_type], block_prev, 0, 0, cptr); cptr = p->tmp_buf + no_written; } block_prev = block_free; - no_written += (int)(p->head.block_size[dst_type]) - sizeof(zint); + no_written += CAST_ZINT_TO_INT(p->head.block_size[dst_type]) + - sizeof(zint); p->head.block_used[dst_type]++; } - assert (block_prev != -1); + assert(block_prev != -1); block_free = 0; - memcpy (cptr, &block_free, sizeof(block_free)); - bf_write (p->data_BFile[dst_type], block_prev, 0, + memcpy(cptr, &block_free, sizeof(block_free)); + bf_write(p->data_BFile[dst_type], block_prev, 0, sizeof(block_free) + (p->tmp_buf+size) - cptr, cptr); + return ZEBRA_OK; } -Records rec_open (BFiles bfs, int rw, int compression_method) +Records rec_open(BFiles bfs, int rw, int compression_method) { Records p; int i, r; int version; + ZEBRA_RES ret = ZEBRA_OK; - p = (Records) xmalloc (sizeof(*p)); + p = (Records) xmalloc(sizeof(*p)); p->compression_method = compression_method; p->rw = rw; p->tmp_size = 1024; - p->tmp_buf = (char *) xmalloc (p->tmp_size); p->index_fname = "reci"; - p->index_BFile = bf_open (bfs, p->index_fname, RIDX_CHUNK, rw); + p->index_BFile = bf_open(bfs, p->index_fname, RIDX_CHUNK, rw); if (p->index_BFile == NULL) { - yaz_log (YLOG_FATAL|YLOG_ERRNO, "open %s", p->index_fname); - exit (1); + yaz_log(YLOG_FATAL|YLOG_ERRNO, "open %s", p->index_fname); + xfree(p); + return 0; } - r = bf_read (p->index_BFile, 0, 0, 0, p->tmp_buf); + p->tmp_buf = (char *) xmalloc(p->tmp_size); + r = bf_read(p->index_BFile, 0, 0, 0, p->tmp_buf); switch (r) { case 0: - memcpy (p->head.magic, REC_HEAD_MAGIC, sizeof(p->head.magic)); - sprintf (p->head.version, "%3d", REC_VERSION); + memcpy(p->head.magic, REC_HEAD_MAGIC, sizeof(p->head.magic)); + sprintf(p->head.version, "%3d", REC_VERSION); p->head.index_free = 0; p->head.index_last = 1; p->head.no_records = 0; @@ -280,51 +315,56 @@ Records rec_open (BFiles bfs, int rw, int compression_method) p->head.block_move[i] = p->head.block_size[i] * 24; } if (rw) - rec_write_head (p); + { + if (rec_write_head(p) != ZEBRA_OK) + ret = ZEBRA_FAIL; + } break; case 1: - memcpy (&p->head, p->tmp_buf, sizeof(p->head)); - if (memcmp (p->head.magic, REC_HEAD_MAGIC, sizeof(p->head.magic))) + memcpy(&p->head, p->tmp_buf, sizeof(p->head)); + if (memcmp(p->head.magic, REC_HEAD_MAGIC, sizeof(p->head.magic))) { - yaz_log (YLOG_FATAL, "file %s has bad format", p->index_fname); - exit (1); + yaz_log(YLOG_FATAL, "file %s has bad format", p->index_fname); + ret = ZEBRA_FAIL; } - version = atoi (p->head.version); + version = atoi(p->head.version); if (version != REC_VERSION) { - yaz_log (YLOG_FATAL, "file %s is version %d, but version" + yaz_log(YLOG_FATAL, "file %s is version %d, but version" " %d is required", p->index_fname, version, REC_VERSION); - exit (1); + ret = ZEBRA_FAIL; } break; } for (i = 0; idata_fname[i] = (char *) xmalloc (strlen(str)+1); - strcpy (p->data_fname[i], str); + sprintf(str, "recd%c", i + 'A'); + p->data_fname[i] = (char *) xmalloc(strlen(str)+1); + strcpy(p->data_fname[i], str); p->data_BFile[i] = NULL; } for (i = 0; idata_BFile[i] = bf_open (bfs, p->data_fname[i], - (int) (p->head.block_size[i]), - rw))) + if (!(p->data_BFile[i] = + bf_open(bfs, p->data_fname[i], + CAST_ZINT_TO_INT(p->head.block_size[i]), rw))) { - yaz_log (YLOG_FATAL|YLOG_ERRNO, "bf_open %s", p->data_fname[i]); - exit (1); + yaz_log(YLOG_FATAL|YLOG_ERRNO, "bf_open %s", p->data_fname[i]); + ret = ZEBRA_FAIL; } } p->cache_max = 400; p->cache_cur = 0; p->record_cache = (struct record_cache_entry *) - xmalloc (sizeof(*p->record_cache)*p->cache_max); - zebra_mutex_init (&p->mutex); + xmalloc(sizeof(*p->record_cache)*p->cache_max); + zebra_mutex_init(&p->mutex); + if (ret == ZEBRA_FAIL) + rec_close(&p); return p; } -static void rec_encode_unsigned (unsigned n, unsigned char *buf, int *len) +static void rec_encode_unsigned(unsigned n, unsigned char *buf, int *len) { (*len) = 0; while (n > 127) @@ -354,7 +394,7 @@ static void rec_decode_unsigned(unsigned *np, unsigned char *buf, int *len) *np = n; } -static void rec_encode_zint (zint n, unsigned char *buf, int *len) +static void rec_encode_zint(zint n, unsigned char *buf, int *len) { (*len) = 0; while (n > 127) @@ -384,52 +424,57 @@ static void rec_decode_zint(zint *np, unsigned char *buf, int *len) *np = n; } -static void rec_cache_flush_block1 (Records p, Record rec, Record last_rec, - char **out_buf, int *out_size, - int *out_offset) +static void rec_cache_flush_block1(Records p, Record rec, Record last_rec, + char **out_buf, int *out_size, + int *out_offset) { int i; int len; for (i = 0; isize[i] + 20 > *out_size) + if (*out_offset + CAST_ZINT_TO_INT(rec->size[i]) + 20 > *out_size) { int new_size = *out_offset + rec->size[i] + 65536; - char *np = (char *) xmalloc (new_size); + char *np = (char *) xmalloc(new_size); if (*out_offset) - memcpy (np, *out_buf, *out_offset); - xfree (*out_buf); + memcpy(np, *out_buf, *out_offset); + xfree(*out_buf); *out_size = new_size; *out_buf = np; } if (i == 0) { - rec_encode_zint (rec->sysno, *out_buf + *out_offset, &len); + rec_encode_zint(rec_sysno_to_int(rec->sysno), + (unsigned char *) *out_buf + *out_offset, &len); (*out_offset) += len; } if (rec->size[i] == 0) { - rec_encode_unsigned (1, *out_buf + *out_offset, &len); + rec_encode_unsigned(1, (unsigned char *) *out_buf + *out_offset, + &len); (*out_offset) += len; } else if (last_rec && rec->size[i] == last_rec->size[i] && - !memcmp (rec->info[i], last_rec->info[i], rec->size[i])) + !memcmp(rec->info[i], last_rec->info[i], rec->size[i])) { - rec_encode_unsigned (0, *out_buf + *out_offset, &len); + rec_encode_unsigned(0, (unsigned char *) *out_buf + *out_offset, + &len); (*out_offset) += len; } else { - rec_encode_unsigned (rec->size[i]+1, *out_buf + *out_offset, &len); + rec_encode_unsigned(rec->size[i]+1, + (unsigned char *) *out_buf + *out_offset, + &len); (*out_offset) += len; - memcpy (*out_buf + *out_offset, rec->info[i], rec->size[i]); + memcpy(*out_buf + *out_offset, rec->info[i], rec->size[i]); (*out_offset) += rec->size[i]; } } } -static void rec_write_multiple (Records p, int saveCount) +static ZEBRA_RES rec_write_multiple(Records p, int saveCount) { int i; short ref_count = 0; @@ -437,9 +482,10 @@ static void rec_write_multiple (Records p, int saveCount) Record last_rec = 0; int out_size = 1000; int out_offset = 0; - char *out_buf = (char *) xmalloc (out_size); - SYSNO *sysnos = (SYSNO *) xmalloc (sizeof(*sysnos) * (p->cache_cur + 1)); + char *out_buf = (char *) xmalloc(out_size); + SYSNO *sysnos = (SYSNO *) xmalloc(sizeof(*sysnos) * (p->cache_cur + 1)); SYSNO *sysnop = sysnos; + ZEBRA_RES ret = ZEBRA_OK; for (i = 0; icache_cur - saveCount; i++) { @@ -447,24 +493,29 @@ static void rec_write_multiple (Records p, int saveCount) switch (e->flag) { case recordFlagNew: - rec_cache_flush_block1 (p, e->rec, last_rec, &out_buf, + rec_cache_flush_block1(p, e->rec, last_rec, &out_buf, &out_size, &out_offset); - *sysnop++ = e->rec->sysno; + *sysnop++ = rec_sysno_to_int(e->rec->sysno); ref_count++; e->flag = recordFlagNop; last_rec = e->rec; break; case recordFlagWrite: - rec_release_blocks (p, e->rec->sysno); - rec_cache_flush_block1 (p, e->rec, last_rec, &out_buf, + if (rec_release_blocks(p, rec_sysno_to_int(e->rec->sysno)) + != ZEBRA_OK) + ret = ZEBRA_FAIL; + + rec_cache_flush_block1(p, e->rec, last_rec, &out_buf, &out_size, &out_offset); - *sysnop++ = e->rec->sysno; + *sysnop++ = rec_sysno_to_int(e->rec->sysno); ref_count++; e->flag = recordFlagNop; last_rec = e->rec; break; case recordFlagDelete: - rec_delete_single (p, e->rec); + if (rec_delete_single(p, e->rec) != ZEBRA_OK) + ret = ZEBRA_FAIL; + e->flag = recordFlagNop; break; default: @@ -475,28 +526,28 @@ static void rec_write_multiple (Records p, int saveCount) *sysnop = -1; if (ref_count) { - int csize = 0; /* indicate compression "not performed yet" */ + unsigned int csize = 0; /* indicate compression "not performed yet" */ compression_method = p->compression_method; switch (compression_method) { case REC_COMPRESS_BZIP2: #if HAVE_BZLIB_H csize = out_offset + (out_offset >> 6) + 620; - rec_tmp_expand (p, csize); + rec_tmp_expand(p, csize); #ifdef BZ_CONFIG_ERROR i = BZ2_bzBuffToBuffCompress #else i = bzBuffToBuffCompress #endif - (p->tmp_buf+sizeof(zint)+sizeof(short)+ + (p->tmp_buf+sizeof(zint)+sizeof(short)+ sizeof(char), &csize, out_buf, out_offset, 1, 0, 30); if (i != BZ_OK) { - yaz_log (YLOG_WARN, "bzBuffToBuffCompress error code=%d", i); + yaz_log(YLOG_WARN, "bzBuffToBuffCompress error code=%d", i); csize = 0; } - yaz_log (YLOG_LOG, "compress %4d %5d %5d", ref_count, out_offset, + yaz_log(YLOG_LOG, "compress %4d %5d %5d", ref_count, out_offset, csize); #endif break; @@ -507,46 +558,51 @@ static void rec_write_multiple (Records p, int saveCount) { /* either no compression or compression not supported ... */ csize = out_offset; - rec_tmp_expand (p, csize); - memcpy (p->tmp_buf + sizeof(zint) + sizeof(short) + sizeof(char), + rec_tmp_expand(p, csize); + memcpy(p->tmp_buf + sizeof(zint) + sizeof(short) + sizeof(char), out_buf, out_offset); csize = out_offset; compression_method = REC_COMPRESS_NONE; } - memcpy (p->tmp_buf + sizeof(zint), &ref_count, sizeof(ref_count)); - memcpy (p->tmp_buf + sizeof(zint)+sizeof(short), + memcpy(p->tmp_buf + sizeof(zint), &ref_count, sizeof(ref_count)); + memcpy(p->tmp_buf + sizeof(zint)+sizeof(short), &compression_method, sizeof(compression_method)); /* -------- compression */ - rec_write_tmp_buf (p, csize + sizeof(short) + sizeof(char), sysnos); + if (rec_write_tmp_buf(p, csize + sizeof(short) + sizeof(char), sysnos) + != ZEBRA_OK) + ret = ZEBRA_FAIL; } - xfree (out_buf); - xfree (sysnos); + xfree(out_buf); + xfree(sysnos); + return ret; } -static void rec_cache_flush (Records p, int saveCount) +static ZEBRA_RES rec_cache_flush(Records p, int saveCount) { int i, j; + ZEBRA_RES ret; if (saveCount >= p->cache_cur) saveCount = 0; - rec_write_multiple (p, saveCount); + ret = rec_write_multiple(p, saveCount); for (i = 0; icache_cur - saveCount; i++) { struct record_cache_entry *e = p->record_cache + i; - rec_rm (&e->rec); + rec_rm(&e->rec); } /* i still being used ... */ for (j = 0; jrecord_cache+j, p->record_cache+i, + memcpy(p->record_cache+j, p->record_cache+i, sizeof(*p->record_cache)); p->cache_cur = saveCount; + return ret; } -static Record *rec_cache_lookup (Records p, SYSNO sysno, - enum recordCacheFlag flag) +static Record *rec_cache_lookup(Records p, SYSNO sysno, + enum recordCacheFlag flag) { int i; for (i = 0; icache_cur; i++) @@ -562,12 +618,13 @@ static Record *rec_cache_lookup (Records p, SYSNO sysno, return NULL; } -static void rec_cache_insert (Records p, Record rec, enum recordCacheFlag flag) +static ZEBRA_RES rec_cache_insert(Records p, Record rec, enum recordCacheFlag flag) { struct record_cache_entry *e; + ZEBRA_RES ret = ZEBRA_OK; if (p->cache_cur == p->cache_max) - rec_cache_flush (p, 1); + ret = rec_cache_flush(p, 1); else if (p->cache_cur > 0) { int i, j; @@ -579,44 +636,53 @@ static void rec_cache_insert (Records p, Record rec, enum recordCacheFlag flag) used += r->size[j]; } if (used > 90000) - rec_cache_flush (p, 1); + ret = rec_cache_flush(p, 1); } - assert (p->cache_cur < p->cache_max); + assert(p->cache_cur < p->cache_max); e = p->record_cache + (p->cache_cur)++; e->flag = flag; - e->rec = rec_cp (rec); + e->rec = rec_cp(rec); + return ret; } -void rec_close (Records *pp) +ZEBRA_RES rec_close(Records *pp) { Records p = *pp; int i; + ZEBRA_RES ret = ZEBRA_OK; + + if (!p) + return ret; - assert (p); + zebra_mutex_destroy(&p->mutex); + if (rec_cache_flush(p, 0) != ZEBRA_OK) + ret = ZEBRA_FAIL; - zebra_mutex_destroy (&p->mutex); - rec_cache_flush (p, 0); - xfree (p->record_cache); + xfree(p->record_cache); if (p->rw) - rec_write_head (p); + { + if (rec_write_head(p) != ZEBRA_OK) + ret = ZEBRA_FAIL; + } if (p->index_BFile) - bf_close (p->index_BFile); + bf_close(p->index_BFile); for (i = 0; idata_BFile[i]) - bf_close (p->data_BFile[i]); - xfree (p->data_fname[i]); + bf_close(p->data_BFile[i]); + xfree(p->data_fname[i]); } - xfree (p->tmp_buf); - xfree (p); + xfree(p->tmp_buf); + xfree(p); *pp = NULL; + return ret; } -static Record rec_get_int (Records p, SYSNO sysno) +static Record rec_get_int(Records p, SYSNO sysno) { int i, in_size, r; Record rec, *recp; @@ -627,35 +693,35 @@ static Record rec_get_int (Records p, SYSNO sysno) char *in_buf = 0; char *bz_buf = 0; #if HAVE_BZLIB_H - int bz_size; + unsigned int bz_size; #endif char compression_method; - assert (sysno > 0); - assert (p); + assert(sysno > 0); + assert(p); - if ((recp = rec_cache_lookup (p, sysno, recordFlagNop))) - return rec_cp (*recp); + if ((recp = rec_cache_lookup(p, sysno, recordFlagNop))) + return rec_cp(*recp); - if (read_indx (p, sysno, &entry, sizeof(entry), 1) < 1) + if (read_indx(p, rec_sysno_to_int(sysno), &entry, sizeof(entry), 1) < 1) return NULL; /* record is not there! */ if (!entry.size) return NULL; /* record is deleted */ dst_type = (int) (entry.next & 7); - assert (dst_type < REC_BLOCK_TYPES); + assert(dst_type < REC_BLOCK_TYPES); freeblock = entry.next / 8; - assert (freeblock > 0); + assert(freeblock > 0); - rec_tmp_expand (p, entry.size); + rec_tmp_expand(p, entry.size); cptr = p->tmp_buf; - r = 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(&freeblock, cptr, sizeof(freeblock)); while (freeblock) { @@ -663,17 +729,17 @@ static Record rec_get_int (Records p, SYSNO sysno) cptr += p->head.block_size[dst_type] - sizeof(freeblock); - memcpy (&tmp, cptr, sizeof(tmp)); - r = bf_read (p->data_BFile[dst_type], freeblock, 0, 0, cptr); + memcpy(&tmp, cptr, sizeof(tmp)); + 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)); + memcpy(&freeblock, cptr, sizeof(freeblock)); + memcpy(cptr, &tmp, sizeof(tmp)); } - rec = (Record) xmalloc (sizeof(*rec)); + rec = (Record) xmalloc(sizeof(*rec)); rec->sysno = sysno; - memcpy (&compression_method, p->tmp_buf + sizeof(zint) + sizeof(short), + memcpy(&compression_method, p->tmp_buf + sizeof(zint) + sizeof(short), sizeof(compression_method)); in_buf = p->tmp_buf + sizeof(zint) + sizeof(short) + sizeof(char); in_size = entry.size - sizeof(short) - sizeof(char); @@ -684,25 +750,25 @@ static Record rec_get_int (Records p, SYSNO sysno) bz_size = entry.size * 20 + 100; while (1) { - bz_buf = (char *) xmalloc (bz_size); + bz_buf = (char *) xmalloc(bz_size); #ifdef BZ_CONFIG_ERROR i = BZ2_bzBuffToBuffDecompress #else i = bzBuffToBuffDecompress #endif - (bz_buf, &bz_size, in_buf, in_size, 0, 0); - yaz_log (YLOG_LOG, "decompress %5d %5d", in_size, bz_size); + (bz_buf, &bz_size, in_buf, in_size, 0, 0); + yaz_log(YLOG_LOG, "decompress %5d %5d", in_size, bz_size); if (i == BZ_OK) break; - yaz_log (YLOG_LOG, "failed"); - xfree (bz_buf); + yaz_log(YLOG_LOG, "failed"); + xfree(bz_buf); bz_size *= 2; } in_buf = bz_buf; in_size = bz_size; #else - yaz_log (YLOG_FATAL, "cannot decompress record(s) in BZIP2 format"); - exit (1); + yaz_log(YLOG_FATAL, "cannot decompress record(s) in BZIP2 format"); + return 0; #endif break; case REC_COMPRESS_NONE: @@ -716,13 +782,13 @@ static Record rec_get_int (Records p, SYSNO sysno) { zint this_sysno; int len; - rec_decode_zint (&this_sysno, nptr, &len); + rec_decode_zint(&this_sysno, (unsigned char *) nptr, &len); nptr += len; for (i = 0; i < REC_NO_INFO; i++) { - int this_size; - rec_decode_unsigned (&this_size, nptr, &len); + unsigned int this_size; + rec_decode_unsigned(&this_size, (unsigned char *) nptr, &len); nptr += len; if (this_size == 0) @@ -737,135 +803,149 @@ static Record rec_get_int (Records p, SYSNO sysno) else rec->info[i] = NULL; } - if (this_sysno == sysno) + if (this_sysno == rec_sysno_to_int(sysno)) break; } for (i = 0; iinfo[i] && rec->size[i]) { - char *np = xmalloc (rec->size[i]+1); - memcpy (np, rec->info[i], rec->size[i]); + char *np = xmalloc(rec->size[i]+1); + memcpy(np, rec->info[i], rec->size[i]); np[rec->size[i]] = '\0'; rec->info[i] = np; } else { - assert (rec->info[i] == 0); - assert (rec->size[i] == 0); + assert(rec->info[i] == 0); + assert(rec->size[i] == 0); } } - xfree (bz_buf); - rec_cache_insert (p, rec, recordFlagNop); + xfree(bz_buf); + if (rec_cache_insert(p, rec, recordFlagNop) != ZEBRA_OK) + return 0; return rec; } -Record rec_get (Records p, SYSNO sysno) +Record rec_get(Records p, SYSNO sysno) { Record rec; - zebra_mutex_lock (&p->mutex); + zebra_mutex_lock(&p->mutex); - rec = rec_get_int (p, sysno); - zebra_mutex_unlock (&p->mutex); + rec = rec_get_int(p, sysno); + zebra_mutex_unlock(&p->mutex); return rec; } -static Record rec_new_int (Records p) +Record rec_get_root(Records p) +{ + return rec_get(p, rec_sysno_to_ext(1)); +} + +static Record rec_new_int(Records p) { int i; SYSNO sysno; Record rec; - assert (p); - rec = (Record) xmalloc (sizeof(*rec)); + assert(p); + rec = (Record) xmalloc(sizeof(*rec)); if (1 || p->head.index_free == 0) sysno = (p->head.index_last)++; else { struct record_index_entry entry; - read_indx (p, p->head.index_free, &entry, sizeof(entry), 0); + if (read_indx(p, p->head.index_free, &entry, sizeof(entry), 0) < 1) + { + xfree(rec); + return 0; + } sysno = p->head.index_free; p->head.index_free = entry.next; } (p->head.no_records)++; - rec->sysno = sysno; + rec->sysno = rec_sysno_to_ext(sysno); for (i = 0; i < REC_NO_INFO; i++) { rec->info[i] = NULL; rec->size[i] = 0; } - rec_cache_insert (p, rec, recordFlagNew); + rec_cache_insert(p, rec, recordFlagNew); return rec; } -Record rec_new (Records p) +Record rec_new(Records p) { Record rec; - zebra_mutex_lock (&p->mutex); + zebra_mutex_lock(&p->mutex); - rec = rec_new_int (p); - zebra_mutex_unlock (&p->mutex); + rec = rec_new_int(p); + zebra_mutex_unlock(&p->mutex); return rec; } -void rec_del (Records p, Record *recpp) +ZEBRA_RES rec_del(Records p, Record *recpp) { Record *recp; + ZEBRA_RES ret = ZEBRA_OK; - zebra_mutex_lock (&p->mutex); + zebra_mutex_lock(&p->mutex); (p->head.no_records)--; - if ((recp = rec_cache_lookup (p, (*recpp)->sysno, recordFlagDelete))) + if ((recp = rec_cache_lookup(p, (*recpp)->sysno, recordFlagDelete))) { - rec_rm (recp); + rec_rm(recp); *recp = *recpp; } else { - rec_cache_insert (p, *recpp, recordFlagDelete); - rec_rm (recpp); + ret = rec_cache_insert(p, *recpp, recordFlagDelete); + rec_rm(recpp); } - zebra_mutex_unlock (&p->mutex); + zebra_mutex_unlock(&p->mutex); *recpp = NULL; + return ret; } -void rec_put (Records p, Record *recpp) +ZEBRA_RES rec_put(Records p, Record *recpp) { Record *recp; + ZEBRA_RES ret = ZEBRA_OK; - zebra_mutex_lock (&p->mutex); - if ((recp = rec_cache_lookup (p, (*recpp)->sysno, recordFlagWrite))) + zebra_mutex_lock(&p->mutex); + if ((recp = rec_cache_lookup(p, (*recpp)->sysno, recordFlagWrite))) { - rec_rm (recp); + rec_rm(recp); *recp = *recpp; } else { - rec_cache_insert (p, *recpp, recordFlagWrite); - rec_rm (recpp); + ret = rec_cache_insert(p, *recpp, recordFlagWrite); + rec_rm(recpp); } - zebra_mutex_unlock (&p->mutex); + zebra_mutex_unlock(&p->mutex); *recpp = NULL; + return ret; } -void rec_rm (Record *recpp) +void rec_rm(Record *recpp) { int i; if (!*recpp) return ; for (i = 0; i < REC_NO_INFO; i++) - xfree ((*recpp)->info[i]); - xfree (*recpp); + xfree((*recpp)->info[i]); + xfree(*recpp); *recpp = NULL; } -Record rec_cp (Record rec) +Record rec_cp(Record rec) { Record n; int i; - n = (Record) xmalloc (sizeof(*n)); + n = (Record) xmalloc(sizeof(*n)); n->sysno = rec->sysno; for (i = 0; i < REC_NO_INFO; i++) if (!rec->info[i]) @@ -876,14 +956,15 @@ Record rec_cp (Record rec) else { n->size[i] = rec->size[i]; - n->info[i] = (char *) xmalloc (rec->size[i]); - memcpy (n->info[i], rec->info[i], rec->size[i]); + n->info[i] = (char *) xmalloc(rec->size[i]+1); + memcpy(n->info[i], rec->info[i], rec->size[i]); + n->info[i][rec->size[i]] = '\0'; } return n; } -char *rec_strdup (const char *s, size_t *len) +char *rec_strdup(const char *s, size_t *len) { char *p; @@ -893,8 +974,16 @@ char *rec_strdup (const char *s, size_t *len) return NULL; } *len = strlen(s)+1; - p = (char *) xmalloc (*len); - strcpy (p, s); + p = (char *) xmalloc(*len); + strcpy(p, s); return p; } +/* + * Local variables: + * c-basic-offset: 4 + * indent-tabs-mode: nil + * End: + * vim: shiftwidth=4 tabstop=8 expandtab + */ +