/*
- * Copyright (C) 1994-1998, Index Data I/S
+ * Copyright (C) 1994-1999, Index Data
* All rights reserved.
* Sebastian Hammer, Adam Dickmeiss
*
* $Log: mfile.c,v $
- * Revision 1.27 1998-02-10 11:55:07 adam
+ * Revision 1.40 2000-10-17 12:37:09 adam
+ * Fixed notification of live-updates. Fixed minor problem with mf_init
+ * where it didn't handle shadow area file names correctly.
+ *
+ * Revision 1.39 2000/05/05 13:48:03 adam
+ * Fixed locking for metafiles.
+ *
+ * Revision 1.38 2000/03/20 19:08:35 adam
+ * Added remote record import using Z39.50 extended services and Segment
+ * Requests.
+ *
+ * Revision 1.37 2000/03/15 15:00:30 adam
+ * First work on threaded version.
+ *
+ * Revision 1.36 1999/12/08 15:03:11 adam
+ * Implemented bf_reset.
+ *
+ * Revision 1.35 1999/10/14 14:33:50 adam
+ * Added truncation 5=106.
+ *
+ * Revision 1.34 1999/05/26 07:49:12 adam
+ * C++ compilation.
+ *
+ * Revision 1.33 1999/05/12 13:08:06 adam
+ * First version of ISAMS.
+ *
+ * Revision 1.32 1999/04/28 14:53:07 adam
+ * Fixed stupid bug regarding split-files.
+ *
+ * Revision 1.31 1999/02/18 12:49:33 adam
+ * Changed file naming scheme for register files as well as record
+ * store/index files.
+ *
+ * Revision 1.30 1999/02/02 14:50:02 adam
+ * Updated WIN32 code specific sections. Changed header.
+ *
+ * Revision 1.29 1998/05/27 14:28:34 adam
+ * Fixed bug in mf_write. 'Cap off' byte written at wrong offset.
+ *
+ * Revision 1.28 1998/05/20 10:00:35 adam
+ * Fixed register spec so that colon isn't treated as size separator
+ * unless followed by [0-9+-] in order to allow DOS drive specifications.
+ *
+ * Revision 1.27 1998/02/10 11:55:07 adam
* Minor changes.
*
* Revision 1.26 1997/10/27 14:25:38 adam
#include <sys/types.h>
#include <fcntl.h>
-#ifdef WINDOWS
+#ifdef WIN32
#include <io.h>
#else
#include <unistd.h>
#include <assert.h>
#include <errno.h>
+#include <zebra-lock.h>
#include <zebrautl.h>
#include <mfile.h>
for (;;)
{
const char *ad0 = ad;
- int i = 0, fact = 1, multi, size = 0;
+ int i = 0, fact = 1, multi;
+ off_t size = 0;
while (*ad == ' ' || *ad == '\t')
ad++;
if (!*ad)
break;
- while (*ad && *ad != ':')
+ while (*ad)
{
+ if (*ad == ':' && strchr ("+-0123456789", ad[1]))
+ break;
if (i < FILENAME_MAX)
dirname[i++] = *ad;
ad++;
dirname[i] = '\0';
if (*ad++ != ':')
{
- logf (LOG_FATAL, "Missing colon after path: %s", ad0);
+ logf (LOG_WARN, "Missing colon after path: %s", ad0);
return -1;
}
if (i == 0)
{
- logf (LOG_FATAL, "Empty path: %s", ad0);
+ logf (LOG_WARN, "Empty path: %s", ad0);
return -1;
}
while (*ad == ' ' || *ad == '\t')
size = size*10 + (*ad++ - '0');
switch (*ad)
{
- case 'B': case 'b': multi = 1; break;
- case 'K': case 'k': multi = 1024; break;
- case 'M': case 'm': multi = 1048576; break;
+ case 'B': case 'b': multi = 1; break;
+ case 'K': case 'k': multi = 1024; break;
+ case 'M': case 'm': multi = 1048576; break;
+ case 'G': case 'g': multi = 1073741824; break;
case '\0':
logf (LOG_FATAL, "Missing unit: %s", ad0);
return -1;
return -1;
}
ad++;
- *dp = dir = xmalloc(sizeof(mf_dir));
+ *dp = dir = (mf_dir *) xmalloc(sizeof(mf_dir));
dir->next = 0;
strcpy(dir->name, dirname);
dir->max_bytes = dir->avail_bytes = fact * size * multi;
{
if (!mf->wr && errno == ENOENT && off == 0)
return -2;
- logf (LOG_FATAL|LOG_ERRNO, "Failed to open %s", mf->files[c].path);
+ logf (LOG_WARN|LOG_ERRNO, "Failed to open %s", mf->files[c].path);
return -1;
}
if (lseek(mf->files[c].fd, (ps = pos - off) * mf->blocksize + offset,
SEEK_SET) < 0)
{
- logf (LOG_FATAL|LOG_ERRNO, "Failed to seek in %s", mf->files[c].path);
+ logf (LOG_WARN|LOG_ERRNO, "Failed to seek in %s", mf->files[c].path);
return -1;
}
mf->cur_file = c;
*/
MFile_area mf_init(const char *name, const char *spec)
{
- MFile_area ma = xmalloc(sizeof(*ma));
+ MFile_area ma = (MFile_area) xmalloc(sizeof(*ma));
mf_dir *dirp;
meta_file *meta_f;
part_file *part_f = 0;
ma->dirs = 0;
if (scan_areadef(ma, name, spec) < 0)
{
- logf (LOG_FATAL, "Failed to access description of '%s'", name);
+ logf (LOG_WARN, "Failed to access description of '%s'", name);
return 0;
}
/* look at each directory */
{
if (!(dd = opendir(dirp->name)))
{
- logf (LOG_FATAL|LOG_ERRNO, "Failed to open %s", dirp->name);
+ logf (LOG_WARN|LOG_ERRNO, "Failed to open directory %s",
+ dirp->name);
return 0;
}
/* look at each file */
while ((dent = readdir(dd)))
{
- if (*dent->d_name == '.')
- continue;
- if (sscanf(dent->d_name, "%[^.].mf.%d", metaname, &number) != 2)
+ int len = strlen(dent->d_name);
+ const char *cp = strrchr (dent->d_name, '-');
+ if (strchr (".-", *dent->d_name))
+ continue;
+ if (len < 5 || !cp || strcmp (dent->d_name + len - 3, ".mf"))
{
- logf (LOG_DEBUG, "bf: %s is not a part-file.", dent->d_name);
- continue;
+ logf (LOG_WARN, "bf: %s is not a part-file.", dent->d_name);
+ continue;
}
+ number = atoi(cp+1);
+ memcpy (metaname, dent->d_name, cp - dent->d_name);
+ metaname[ cp - dent->d_name] = '\0';
+
for (meta_f = ma->mfiles; meta_f; meta_f = meta_f->next)
{
/* known metafile */
/* new metafile */
if (!meta_f)
{
- meta_f = xmalloc(sizeof(*meta_f));
+ meta_f = (meta_file *) xmalloc(sizeof(*meta_f));
+ zebra_mutex_init (&meta_f->mutex);
meta_f->ma = ma;
meta_f->next = ma->mfiles;
meta_f->open = 0;
{
xfree (m->files[i].path);
}
+ zebra_mutex_destroy (&meta_f->mutex);
meta_f = meta_f->next;
xfree (m);
}
xfree (ma);
}
+void mf_reset(MFile_area ma)
+{
+ meta_file *meta_f;
+
+ if (!ma)
+ return;
+ meta_f = ma->mfiles;
+ while (meta_f)
+ {
+ int i;
+ meta_file *m = meta_f;
+
+ assert (!m->open);
+ for (i = 0; i<m->no_files; i++)
+ {
+ unlink (m->files[i].path);
+ xfree (m->files[i].path);
+ }
+ meta_f = meta_f->next;
+ xfree (m);
+ }
+ ma->mfiles = 0;
+}
+
/*
* Open a metafile.
* If !ma, Use MF_DEFAULT_AREA.
*/
MFile mf_open(MFile_area ma, const char *name, int block_size, int wflag)
{
- struct meta_file *mnew;
+ meta_file *mnew;
int i;
char tmp[FILENAME_MAX+1];
mf_dir *dp;
assert (ma);
for (mnew = ma->mfiles; mnew; mnew = mnew->next)
if (!strcmp(name, mnew->name))
+ {
if (mnew->open)
abort();
else
break;
+ }
if (!mnew)
{
- mnew = xmalloc(sizeof(*mnew));
+ mnew = (meta_file *) xmalloc(sizeof(*mnew));
strcpy(mnew->name, name);
/* allocate one, empty file */
+ zebra_mutex_init (&mnew->mutex);
mnew->no_files = 1;
- mnew->files[0].bytes = mnew->files[0].blocks = 0;
+ mnew->files[0].bytes = 0;
+ mnew->files[0].blocks = 0;
mnew->files[0].top = -1;
mnew->files[0].number = 0;
mnew->files[0].fd = -1;
return 0;
}
mnew->files[0].dir = dp;
- sprintf(tmp, "%s/%s.mf.%d", dp->name, mnew->name, 0);
+ sprintf(tmp, "%s/%s-%d.mf", dp->name, mnew->name, 0);
mnew->files[0].path = xstrdup(tmp);
mnew->ma = ma;
mnew->next = ma->mfiles;
/*
* Read one block from a metafile. Interface mirrors bfile.
*/
-int mf_read(MFile mf, int no, int offset, int num, void *buf)
+int mf_read(MFile mf, int no, int offset, int nbytes, void *buf)
{
int rd, toread;
+ zebra_mutex_lock (&mf->mutex);
if ((rd = file_position(mf, no, offset)) < 0)
+ {
if (rd == -2)
+ {
+ zebra_mutex_unlock (&mf->mutex);
return 0;
+ }
else
exit(1);
- toread = num ? num : mf->blocksize;
+ }
+ toread = nbytes ? nbytes : mf->blocksize;
if ((rd = read(mf->files[mf->cur_file].fd, buf, toread)) < 0)
{
logf (LOG_FATAL|LOG_ERRNO, "mf_read: Read failed (%s)",
mf->files[mf->cur_file].path);
exit(1);
}
- else if (rd < toread)
+ zebra_mutex_unlock (&mf->mutex);
+ if (rd < toread)
return 0;
else
return 1;
/*
* Write.
*/
-int mf_write(MFile mf, int no, int offset, int num, const void *buf)
+int mf_write(MFile mf, int no, int offset, int nbytes, const void *buf)
{
int ps, nblocks, towrite;
mf_dir *dp;
char tmp[FILENAME_MAX+1];
unsigned char dummych = '\xff';
+ zebra_mutex_lock (&mf->mutex);
if ((ps = file_position(mf, no, offset)) < 0)
exit(1);
/* file needs to grow */
mf->files[mf->cur_file].path, nblocks);
if ((ps = file_position(mf,
(mf->cur_file ? mf->files[mf->cur_file-1].top : 0) +
- mf->files[mf->cur_file].blocks + nblocks, 0)) < 0)
+ mf->files[mf->cur_file].blocks + nblocks - 1, 0)) < 0)
exit(1);
+ logf (LOG_DEBUG, "ps = %d", ps);
if (write(mf->files[mf->cur_file].fd, &dummych, 1) < 1)
{
logf (LOG_ERRNO|LOG_FATAL, "write dummy");
mf->files[mf->cur_file].blocks =
mf->files[mf->cur_file].bytes = 0;
mf->files[mf->cur_file].fd = -1;
- sprintf(tmp, "%s/%s.mf.%d", dp->name, mf->name,
+ sprintf(tmp, "%s/%s-%d.mf", dp->name, mf->name,
mf->files[mf->cur_file].number);
mf->files[mf->cur_file].path = xstrdup(tmp);
mf->no_files++;
nblocks * mf->blocksize;
}
}
- towrite = num ? num : mf->blocksize;
+ towrite = nbytes ? nbytes : mf->blocksize;
if (write(mf->files[mf->cur_file].fd, buf, towrite) < towrite)
{
logf (LOG_FATAL|LOG_ERRNO, "Write failed for file %s part %d",
mf->name, mf->cur_file);
exit(1);
}
+ zebra_mutex_unlock (&mf->mutex);
return 0;
}
projects / idzebra-moved-to-github.git / blobdiff