summaryrefslogtreecommitdiff
path: root/qdbm/curia.c
diff options
context:
space:
mode:
Diffstat (limited to 'qdbm/curia.c')
-rw-r--r--qdbm/curia.c1192
1 files changed, 1192 insertions, 0 deletions
diff --git a/qdbm/curia.c b/qdbm/curia.c
new file mode 100644
index 00000000..100529d0
--- /dev/null
+++ b/qdbm/curia.c
@@ -0,0 +1,1192 @@
+/*************************************************************************************************
+ * Implementation of Curia
+ * Copyright (C) 2000-2007 Mikio Hirabayashi
+ * This file is part of QDBM, Quick Database Manager.
+ * QDBM is free software; you can redistribute it and/or modify it under the terms of the GNU
+ * Lesser General Public License as published by the Free Software Foundation; either version
+ * 2.1 of the License or any later version. QDBM is distributed in the hope that it will be
+ * useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+ * details.
+ * You should have received a copy of the GNU Lesser General Public License along with QDBM; if
+ * not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ * 02111-1307 USA.
+ *************************************************************************************************/
+
+
+#define QDBM_INTERNAL 1
+
+#include "curia.h"
+#include "myconf.h"
+
+#define CR_NAMEMAX 512 /* max size of a database name */
+#define CR_DPMAX 512 /* max number of division of a database */
+#define CR_DIRMODE 00755 /* permission of a creating directory */
+#define CR_FILEMODE 00644 /* permission of a creating file */
+#define CR_PATHBUFSIZ 1024 /* size of a path buffer */
+#define CR_DEFDNUM 5 /* default number of division of a database */
+#define CR_ATTRBNUM 16 /* bucket number of attrubute database */
+#define CR_DPNAME "depot" /* name of each sub database */
+#define CR_KEYDNUM "dnum" /* key of division number */
+#define CR_KEYLRNUM "lrnum" /* key of the number of large objects */
+#define CR_TMPFSUF MYEXTSTR "crtmp" /* suffix of a temporary directory */
+#define CR_LOBDIR "lob" /* name of the directory of large objects */
+#define CR_LOBDDEPTH 2 /* depth of the directories of large objects */
+#define CR_NUMBUFSIZ 32 /* size of a buffer for a number */
+#define CR_IOBUFSIZ 8192 /* size of an I/O buffer */
+
+
+/* private function prototypes */
+static char *crstrdup(const char *str);
+static int crdpgetnum(DEPOT *depot, const char *kbuf, int ksiz);
+static char *crgetlobpath(CURIA *curia, const char *kbuf, int ksiz);
+static int crmklobdir(const char *path);
+static int crrmlobdir(const char *path);
+static int crcplobdir(CURIA *curia, const char *path);
+static int crwrite(int fd, const void *buf, int size);
+static int crread(int fd, void *buf, int size);
+
+
+
+/*************************************************************************************************
+ * public objects
+ *************************************************************************************************/
+
+
+/* Get a database handle. */
+CURIA *cropen(const char *name, int omode, int bnum, int dnum){
+ DEPOT *attr, **depots;
+ char path[CR_PATHBUFSIZ], *tname;
+ int i, j, dpomode, inode, lrnum;
+ struct stat sbuf;
+ CURIA *curia;
+ assert(name);
+ if(dnum < 1) dnum = CR_DEFDNUM;
+ if(dnum > CR_DPMAX) dnum = CR_DPMAX;
+ if(strlen(name) > CR_NAMEMAX){
+ dpecodeset(DP_EMISC, __FILE__, __LINE__);
+ return NULL;
+ }
+ dpomode = DP_OREADER;
+ if(omode & CR_OWRITER){
+ dpomode = DP_OWRITER;
+ if(omode & CR_OCREAT) dpomode |= DP_OCREAT;
+ if(omode & CR_OTRUNC) dpomode |= DP_OTRUNC;
+ if(omode & CR_OSPARSE) dpomode |= DP_OSPARSE;
+ }
+ if(omode & CR_ONOLCK) dpomode |= DP_ONOLCK;
+ if(omode & CR_OLCKNB) dpomode |= DP_OLCKNB;
+ attr = NULL;
+ lrnum = 0;
+ if((omode & CR_OWRITER) && (omode & CR_OCREAT)){
+ if(mkdir(name, CR_DIRMODE) == -1 && errno != EEXIST){
+ dpecodeset(DP_EMKDIR, __FILE__, __LINE__);
+ return NULL;
+ }
+ sprintf(path, "%s%c%s", name, MYPATHCHR, CR_DPNAME);
+ if(!(attr = dpopen(path, dpomode, CR_ATTRBNUM))) return NULL;
+ if(dprnum(attr) > 0){
+ if((dnum = crdpgetnum(attr, CR_KEYDNUM, -1)) < 1 ||
+ (lrnum = crdpgetnum(attr, CR_KEYLRNUM, -1)) < 0){
+ dpclose(attr);
+ dpecodeset(DP_EBROKEN, __FILE__, __LINE__);
+ return NULL;
+ }
+ } else {
+ if(!dpput(attr, CR_KEYDNUM, -1, (char *)&dnum, sizeof(int), DP_DOVER) ||
+ !dpput(attr, CR_KEYLRNUM, -1, (char *)&lrnum, sizeof(int), DP_DOVER)){
+ dpclose(attr);
+ return NULL;
+ }
+ for(i = 0; i < dnum; i++){
+ sprintf(path, "%s%c%04d", name, MYPATHCHR, i + 1);
+ if(mkdir(path, CR_DIRMODE) == -1 && errno != EEXIST){
+ dpclose(attr);
+ dpecodeset(DP_EMKDIR, __FILE__, __LINE__);
+ return NULL;
+ }
+ }
+ }
+ }
+ if(!attr){
+ sprintf(path, "%s%c%s", name, MYPATHCHR, CR_DPNAME);
+ if(!(attr = dpopen(path, dpomode, 1))) return NULL;
+ if(!(omode & CR_OTRUNC)){
+ if((dnum = crdpgetnum(attr, CR_KEYDNUM, -1)) < 1 ||
+ (lrnum = crdpgetnum(attr, CR_KEYLRNUM, -1)) < 0){
+ dpclose(attr);
+ dpecodeset(DP_EBROKEN, __FILE__, __LINE__);
+ return NULL;
+ }
+ }
+ }
+ if(omode & CR_OTRUNC){
+ for(i = 0; i < CR_DPMAX; i++){
+ sprintf(path, "%s%c%04d%c%s", name, MYPATHCHR, i + 1, MYPATHCHR, CR_DPNAME);
+ if(unlink(path) == -1 && errno != ENOENT){
+ dpclose(attr);
+ dpecodeset(DP_EUNLINK, __FILE__, __LINE__);
+ return NULL;
+ }
+ sprintf(path, "%s%c%04d%c%s", name, MYPATHCHR, i + 1, MYPATHCHR, CR_LOBDIR);
+ if(!crrmlobdir(path)){
+ dpclose(attr);
+ return NULL;
+ }
+ if(i >= dnum){
+ sprintf(path, "%s%c%04d", name, MYPATHCHR, i + 1);
+ if(rmdir(path) == -1 && errno != ENOENT){
+ dpclose(attr);
+ dpecodeset(DP_ERMDIR, __FILE__, __LINE__);
+ return NULL;
+ }
+ }
+ }
+ errno = 0;
+ }
+ if(lstat(name, &sbuf) == -1){
+ dpclose(attr);
+ dpecodeset(DP_ESTAT, __FILE__, __LINE__);
+ return NULL;
+ }
+ inode = sbuf.st_ino;
+ if(!(depots = malloc(dnum * sizeof(DEPOT *)))){
+ dpclose(attr);
+ dpecodeset(DP_EALLOC, __FILE__, __LINE__);
+ return NULL;
+ }
+ for(i = 0; i < dnum; i++){
+ sprintf(path, "%s%c%04d%c%s", name, MYPATHCHR, i + 1, MYPATHCHR, CR_DPNAME);
+ if(!(depots[i] = dpopen(path, dpomode, bnum))){
+ for(j = 0; j < i; j++){
+ dpclose(depots[j]);
+ }
+ free(depots);
+ dpclose(attr);
+ return NULL;
+ }
+ }
+ curia = malloc(sizeof(CURIA));
+ tname = crstrdup(name);
+ if(!curia || !tname){
+ free(curia);
+ free(tname);
+ for(i = 0; i < dnum; i++){
+ dpclose(depots[i]);
+ }
+ free(depots);
+ dpclose(attr);
+ dpecodeset(DP_EALLOC, __FILE__, __LINE__);
+ return NULL;
+ }
+ curia->name = tname;
+ curia->wmode = (omode & CR_OWRITER);
+ curia->inode = inode;
+ curia->attr = attr;
+ curia->depots = depots;
+ curia->dnum = dnum;
+ curia->inum = 0;
+ curia->lrnum = lrnum;
+ return curia;
+}
+
+
+/* Close a database handle. */
+int crclose(CURIA *curia){
+ int i, err;
+ assert(curia);
+ err = FALSE;
+ for(i = 0; i < curia->dnum; i++){
+ if(!dpclose(curia->depots[i])) err = TRUE;
+ }
+ free(curia->depots);
+ if(curia->wmode){
+ if(!dpput(curia->attr, CR_KEYLRNUM, -1, (char *)&(curia->lrnum), sizeof(int), DP_DOVER))
+ err = TRUE;
+ }
+ if(!dpclose(curia->attr)) err = TRUE;
+ free(curia->name);
+ free(curia);
+ return err ? FALSE : TRUE;
+}
+
+
+/* Store a record. */
+int crput(CURIA *curia, const char *kbuf, int ksiz, const char *vbuf, int vsiz, int dmode){
+ int dpdmode;
+ int tnum;
+ assert(curia && kbuf && vbuf);
+ if(!curia->wmode){
+ dpecodeset(DP_EMODE, __FILE__, __LINE__);
+ return FALSE;
+ }
+ if(ksiz < 0) ksiz = strlen(kbuf);
+ switch(dmode){
+ case CR_DKEEP: dpdmode = DP_DKEEP; break;
+ case CR_DCAT: dpdmode = DP_DCAT; break;
+ default: dpdmode = DP_DOVER; break;
+ }
+ tnum = dpouterhash(kbuf, ksiz) % curia->dnum;
+ return dpput(curia->depots[tnum], kbuf, ksiz, vbuf, vsiz, dpdmode);
+}
+
+
+/* Delete a record. */
+int crout(CURIA *curia, const char *kbuf, int ksiz){
+ int tnum;
+ assert(curia && kbuf);
+ if(!curia->wmode){
+ dpecodeset(DP_EMODE, __FILE__, __LINE__);
+ return FALSE;
+ }
+ if(ksiz < 0) ksiz = strlen(kbuf);
+ tnum = dpouterhash(kbuf, ksiz) % curia->dnum;
+ return dpout(curia->depots[tnum], kbuf, ksiz);
+}
+
+
+/* Retrieve a record. */
+char *crget(CURIA *curia, const char *kbuf, int ksiz, int start, int max, int *sp){
+ int tnum;
+ assert(curia && kbuf && start >= 0);
+ if(ksiz < 0) ksiz = strlen(kbuf);
+ tnum = dpouterhash(kbuf, ksiz) % curia->dnum;
+ return dpget(curia->depots[tnum], kbuf, ksiz, start, max, sp);
+}
+
+
+/* Retrieve a record and write the value into a buffer. */
+int crgetwb(CURIA *curia, const char *kbuf, int ksiz, int start, int max, char *vbuf){
+ int tnum;
+ assert(curia && kbuf && start >= 0 && max >= 0 && vbuf);
+ if(ksiz < 0) ksiz = strlen(kbuf);
+ tnum = dpouterhash(kbuf, ksiz) % curia->dnum;
+ return dpgetwb(curia->depots[tnum], kbuf, ksiz, start, max, vbuf);
+}
+
+
+/* Get the size of the value of a record. */
+int crvsiz(CURIA *curia, const char *kbuf, int ksiz){
+ int tnum;
+ assert(curia && kbuf);
+ if(ksiz < 0) ksiz = strlen(kbuf);
+ tnum = dpouterhash(kbuf, ksiz) % curia->dnum;
+ return dpvsiz(curia->depots[tnum], kbuf, ksiz);
+}
+
+
+/* Initialize the iterator of a database handle. */
+int criterinit(CURIA *curia){
+ int i, err;
+ assert(curia);
+ err = FALSE;
+ for(i = 0; i < curia->dnum; i++){
+ if(!dpiterinit(curia->depots[i])){
+ err = TRUE;
+ break;
+ }
+ }
+ curia->inum = 0;
+ return err ? FALSE : TRUE;
+}
+
+
+/* Get the next key of the iterator. */
+char *criternext(CURIA *curia, int *sp){
+ char *kbuf;
+ assert(curia);
+ kbuf = NULL;
+ while(curia->inum < curia->dnum && !(kbuf = dpiternext(curia->depots[curia->inum], sp))){
+ if(dpecode != DP_ENOITEM) return NULL;
+ (curia->inum)++;
+ }
+ return kbuf;
+}
+
+
+/* Set alignment of a database handle. */
+int crsetalign(CURIA *curia, int align){
+ int i, err;
+ assert(curia);
+ if(!curia->wmode){
+ dpecodeset(DP_EMODE, __FILE__, __LINE__);
+ return FALSE;
+ }
+ err = FALSE;
+ for(i = 0; i < curia->dnum; i++){
+ if(!dpsetalign(curia->depots[i], align)){
+ err = TRUE;
+ break;
+ }
+ }
+ return err ? FALSE : TRUE;
+}
+
+
+/* Set the size of the free block pool of a database handle. */
+int crsetfbpsiz(CURIA *curia, int size){
+ int i, err;
+ assert(curia && size >= 0);
+ if(!curia->wmode){
+ dpecodeset(DP_EMODE, __FILE__, __LINE__);
+ return FALSE;
+ }
+ err = FALSE;
+ for(i = 0; i < curia->dnum; i++){
+ if(!dpsetfbpsiz(curia->depots[i], size)){
+ err = TRUE;
+ break;
+ }
+ }
+ return err ? FALSE : TRUE;
+}
+
+
+/* Synchronize contents of updating a database with the files and the devices. */
+int crsync(CURIA *curia){
+ int i, err;
+ assert(curia);
+ if(!curia->wmode){
+ dpecodeset(DP_EMODE, __FILE__, __LINE__);
+ return FALSE;
+ }
+ err = FALSE;
+ if(!dpput(curia->attr, CR_KEYLRNUM, -1, (char *)&(curia->lrnum), sizeof(int), DP_DOVER) ||
+ !dpsync(curia->attr)) err = TRUE;
+ for(i = 0; i < curia->dnum; i++){
+ if(!dpsync(curia->depots[i])){
+ err = TRUE;
+ break;
+ }
+ }
+ return err ? FALSE : TRUE;
+}
+
+
+/* Optimize a database. */
+int croptimize(CURIA *curia, int bnum){
+ int i, err;
+ assert(curia);
+ if(!curia->wmode){
+ dpecodeset(DP_EMODE, __FILE__, __LINE__);
+ return FALSE;
+ }
+ err = FALSE;
+ for(i = 0; i < curia->dnum; i++){
+ if(!dpoptimize(curia->depots[i], bnum)){
+ err = TRUE;
+ break;
+ }
+ }
+ curia->inum = 0;
+ return err ? FALSE : TRUE;
+}
+
+
+/* Get the name of a database. */
+char *crname(CURIA *curia){
+ char *name;
+ assert(curia);
+ if(!(name = crstrdup(curia->name))){
+ dpecodeset(DP_EALLOC, __FILE__, __LINE__);
+ return NULL;
+ }
+ return name;
+}
+
+
+/* Get the total size of database files. */
+int crfsiz(CURIA *curia){
+ int i, sum, rv;
+ assert(curia);
+ if((sum = dpfsiz(curia->attr)) == -1) return -1;
+ for(i = 0; i < curia->dnum; i++){
+ if((rv = dpfsiz(curia->depots[i])) == -1) return -1;
+ sum += rv;
+ }
+ return sum;
+}
+
+
+/* Get the total size of database files as double-precision value. */
+double crfsizd(CURIA *curia){
+ double sum;
+ int i, rv;
+ assert(curia);
+ sum = 0.0;
+ if((sum = dpfsiz(curia->attr)) < 0) return -1.0;
+ for(i = 0; i < curia->dnum; i++){
+ if((rv = dpfsiz(curia->depots[i])) == -1) return -1.0;
+ sum += rv;
+ }
+ return sum;
+}
+
+
+/* Get the total number of the elements of each bucket array. */
+int crbnum(CURIA *curia){
+ int i, sum, rv;
+ assert(curia);
+ sum = 0;
+ for(i = 0; i < curia->dnum; i++){
+ rv = dpbnum(curia->depots[i]);
+ if(rv == -1) return -1;
+ sum += rv;
+ }
+ return sum;
+}
+
+
+/* Get the total number of the used elements of each bucket array. */
+int crbusenum(CURIA *curia){
+ int i, sum, rv;
+ assert(curia);
+ sum = 0;
+ for(i = 0; i < curia->dnum; i++){
+ rv = dpbusenum(curia->depots[i]);
+ if(rv == -1) return -1;
+ sum += rv;
+ }
+ return sum;
+}
+
+
+/* Get the number of the records stored in a database. */
+int crrnum(CURIA *curia){
+ int i, sum, rv;
+ assert(curia);
+ sum = 0;
+ for(i = 0; i < curia->dnum; i++){
+ rv = dprnum(curia->depots[i]);
+ if(rv == -1) return -1;
+ sum += rv;
+ }
+ return sum;
+}
+
+
+/* Check whether a database handle is a writer or not. */
+int crwritable(CURIA *curia){
+ assert(curia);
+ return curia->wmode;
+}
+
+
+/* Check whether a database has a fatal error or not. */
+int crfatalerror(CURIA *curia){
+ int i;
+ assert(curia);
+ if(dpfatalerror(curia->attr)) return TRUE;
+ for(i = 0; i < curia->dnum; i++){
+ if(dpfatalerror(curia->depots[i])) return TRUE;
+ }
+ return FALSE;
+}
+
+
+/* Get the inode number of a database directory. */
+int crinode(CURIA *curia){
+ assert(curia);
+ return curia->inode;
+}
+
+
+/* Get the last modified time of a database. */
+time_t crmtime(CURIA *curia){
+ assert(curia);
+ return dpmtime(curia->attr);
+}
+
+
+/* Remove a database directory. */
+int crremove(const char *name){
+ struct stat sbuf;
+ CURIA *curia;
+ char path[CR_PATHBUFSIZ];
+ assert(name);
+ if(lstat(name, &sbuf) == -1){
+ dpecodeset(DP_ESTAT, __FILE__, __LINE__);
+ return FALSE;
+ }
+ if((curia = cropen(name, CR_OWRITER | CR_OTRUNC, 1, 1)) != NULL) crclose(curia);
+ sprintf(path, "%s%c0001%c%s", name, MYPATHCHR, MYPATHCHR, CR_DPNAME);
+ dpremove(path);
+ sprintf(path, "%s%c0001", name, MYPATHCHR);
+ if(rmdir(path) == -1){
+ dpecodeset(DP_ERMDIR, __FILE__, __LINE__);
+ return FALSE;
+ }
+ sprintf(path, "%s%c%s", name, MYPATHCHR, CR_DPNAME);
+ if(!dpremove(path)) return FALSE;
+ if(rmdir(name) == -1){
+ dpecodeset(DP_ERMDIR, __FILE__, __LINE__);
+ return FALSE;
+ }
+ return TRUE;
+}
+
+
+/* Repair a broken database directory. */
+int crrepair(const char *name){
+ CURIA *tcuria;
+ DEPOT *tdepot;
+ char path[CR_PATHBUFSIZ], *kbuf, *vbuf;
+ struct stat sbuf;
+ int i, j, err, flags, bnum, dnum, ksiz, vsiz;
+ assert(name);
+ err = FALSE;
+ flags = 0;
+ bnum = 0;
+ dnum = 0;
+ sprintf(path, "%s%c%s", name, MYPATHCHR, CR_DPNAME);
+ if(lstat(path, &sbuf) != -1){
+ if((tdepot = dpopen(path, DP_OREADER, -1)) != NULL){
+ flags = dpgetflags(tdepot);
+ dpclose(tdepot);
+ }
+ }
+ for(i = 1; i <= CR_DPMAX; i++){
+ sprintf(path, "%s%c%04d%c%s", name, MYPATHCHR, i, MYPATHCHR, CR_DPNAME);
+ if(lstat(path, &sbuf) != -1){
+ dnum++;
+ if(!dprepair(path)) err = TRUE;
+ if((tdepot = dpopen(path, DP_OREADER, -1)) != NULL){
+ bnum += dpbnum(tdepot);
+ dpclose(tdepot);
+ }
+ }
+ }
+ if(dnum < CR_DEFDNUM) dnum = CR_DEFDNUM;
+ bnum /= dnum;
+ sprintf(path, "%s%s", name, CR_TMPFSUF);
+ if((tcuria = cropen(path, CR_OWRITER | CR_OCREAT | CR_OTRUNC, bnum, dnum)) != NULL){
+ if(!crsetflags(tcuria, flags)) err = TRUE;
+ for(i = 1; i <= CR_DPMAX; i++){
+ sprintf(path, "%s%c%04d%c%s", name, MYPATHCHR, i, MYPATHCHR, CR_DPNAME);
+ if(lstat(path, &sbuf) != -1){
+ if((tdepot = dpopen(path, DP_OREADER, -1)) != NULL){
+ if(!dpiterinit(tdepot)) err = TRUE;
+ while((kbuf = dpiternext(tdepot, &ksiz)) != NULL){
+ if((vbuf = dpget(tdepot, kbuf, ksiz, 0, -1, &vsiz)) != NULL){
+ if(!crput(tcuria, kbuf, ksiz, vbuf, vsiz, CR_DKEEP)) err = TRUE;
+ free(vbuf);
+ }
+ free(kbuf);
+ }
+ dpclose(tdepot);
+ } else {
+ err = TRUE;
+ }
+ }
+ for(j = 0; j <= CR_DPMAX; j++){
+ sprintf(path, "%s%c%04d%c%s", name, MYPATHCHR, j, MYPATHCHR, CR_LOBDIR);
+ if(lstat(path, &sbuf) != -1){
+ if(!crcplobdir(tcuria, path)) err = TRUE;
+ }
+ }
+ }
+ if(!crclose(tcuria)) err = TRUE;
+ if(!crremove(name)) err = TRUE;
+ sprintf(path, "%s%s", name, CR_TMPFSUF);
+ if(rename(path, name) == -1){
+ if(!err) dpecodeset(DP_EMISC, __FILE__, __LINE__);
+ err = TRUE;
+ }
+ } else {
+ err = TRUE;
+ }
+ return err ? FALSE : TRUE;
+}
+
+
+/* Dump all records as endian independent data. */
+int crexportdb(CURIA *curia, const char *name){
+ char path[CR_PATHBUFSIZ], *kbuf, *vbuf, *pbuf;
+ int i, err, *fds, ksiz, vsiz, psiz;
+ assert(curia && name);
+ if(!(criterinit(curia))) return FALSE;
+ if(mkdir(name, CR_DIRMODE) == -1 && errno != EEXIST){
+ dpecodeset(DP_EMKDIR, __FILE__, __LINE__);
+ return FALSE;
+ }
+ err = FALSE;
+ fds = malloc(sizeof(int) * curia->dnum);
+ for(i = 0; i < curia->dnum; i++){
+ sprintf(path, "%s%c%04d", name, MYPATHCHR, i + 1);
+ if((fds[i] = open(path, O_RDWR | O_CREAT | O_TRUNC, CR_FILEMODE)) == -1){
+ if(!err) dpecodeset(DP_EOPEN, __FILE__, __LINE__);
+ err = TRUE;
+ break;
+ }
+ }
+ while(!err && (kbuf = criternext(curia, &ksiz)) != NULL){
+ if((vbuf = crget(curia, kbuf, ksiz, 0, -1, &vsiz)) != NULL){
+ if((pbuf = malloc(ksiz + vsiz + CR_NUMBUFSIZ * 2)) != NULL){
+ psiz = 0;
+ psiz += sprintf(pbuf + psiz, "%X\n%X\n", ksiz, vsiz);
+ memcpy(pbuf + psiz, kbuf, ksiz);
+ psiz += ksiz;
+ pbuf[psiz++] = '\n';
+ memcpy(pbuf + psiz, vbuf, vsiz);
+ psiz += vsiz;
+ pbuf[psiz++] = '\n';
+ if(!crwrite(fds[curia->inum], pbuf, psiz)){
+ dpecodeset(DP_EWRITE, __FILE__, __LINE__);
+ err = TRUE;
+ }
+ free(pbuf);
+ } else {
+ dpecodeset(DP_EALLOC, __FILE__, __LINE__);
+ err = TRUE;
+ }
+ free(vbuf);
+ } else {
+ err = TRUE;
+ }
+ free(kbuf);
+ }
+ for(i = 0; i < curia->dnum; i++){
+ if(fds[i] != -1 && close(fds[i]) == -1){
+ if(!err) dpecodeset(DP_ECLOSE, __FILE__, __LINE__);
+ err = TRUE;
+ }
+ }
+ free(fds);
+ return !err && !crfatalerror(curia);
+}
+
+
+/* Load all records from endian independent data. */
+int crimportdb(CURIA *curia, const char *name){
+ DEPOT *depot;
+ char ipath[CR_PATHBUFSIZ], opath[CR_PATHBUFSIZ], *kbuf, *vbuf;
+ int i, err, ksiz, vsiz;
+ struct stat sbuf;
+ assert(curia && name);
+ if(!curia->wmode){
+ dpecodeset(DP_EMODE, __FILE__, __LINE__);
+ return FALSE;
+ }
+ if(crrnum(curia) > 0){
+ dpecodeset(DP_EMISC, __FILE__, __LINE__);
+ return FALSE;
+ }
+ err = FALSE;
+ for(i = 0; !err && i < CR_DPMAX; i++){
+ sprintf(ipath, "%s%c%04d", name, MYPATHCHR, i + 1);
+ if(lstat(ipath, &sbuf) == -1 || !S_ISREG(sbuf.st_mode)) break;
+ sprintf(opath, "%s%c%04d%s", curia->name, MYPATHCHR, i + 1, CR_TMPFSUF);
+ if((depot = dpopen(opath, DP_OWRITER | DP_OCREAT | DP_OTRUNC, -1)) != NULL){
+ if(dpimportdb(depot, ipath)){
+ dpiterinit(depot);
+ while((kbuf = dpiternext(depot, &ksiz)) != NULL){
+ if((vbuf = dpget(depot, kbuf, ksiz, 0, -1, &vsiz)) != NULL){
+ if(!crput(curia, kbuf, ksiz, vbuf, vsiz, CR_DKEEP)) err = TRUE;
+ free(vbuf);
+ } else {
+ err = TRUE;
+ }
+ free(kbuf);
+ }
+ } else {
+ err = TRUE;
+ }
+ if(!dpclose(depot)) err = TRUE;
+ if(!dpremove(opath)) err = TRUE;
+ } else {
+ err = TRUE;
+ }
+ }
+ return !err && !crfatalerror(curia);
+}
+
+
+/* Retrieve a record directly from a database directory. */
+char *crsnaffle(const char *name, const char *kbuf, int ksiz, int *sp){
+ char path[CR_PATHBUFSIZ], *vbuf;
+ int dnum, vsiz, tnum;
+ assert(name && kbuf);
+ if(ksiz < 0) ksiz = strlen(kbuf);
+ sprintf(path, "%s%c%s", name, MYPATHCHR, CR_DPNAME);
+ if(!(vbuf = dpsnaffle(path, CR_KEYDNUM, -1, &vsiz)) || vsiz != sizeof(int) ||
+ (dnum = *(int *)vbuf) < 1){
+ free(vbuf);
+ dpecodeset(DP_EBROKEN, __FILE__, __LINE__);
+ return NULL;
+ }
+ free(vbuf);
+ tnum = dpouterhash(kbuf, ksiz) % dnum;
+ sprintf(path, "%s%c%04d%c%s", name, MYPATHCHR, tnum + 1, MYPATHCHR, CR_DPNAME);
+ return dpsnaffle(path, kbuf, ksiz, sp);
+}
+
+
+/* Store a large object. */
+int crputlob(CURIA *curia, const char *kbuf, int ksiz, const char *vbuf, int vsiz, int dmode){
+ char *path;
+ int mode, fd, err, be;
+ struct stat sbuf;
+ assert(curia && kbuf && vbuf);
+ if(!curia->wmode){
+ dpecodeset(DP_EMODE, __FILE__, __LINE__);
+ return FALSE;
+ }
+ if(ksiz < 0) ksiz = strlen(kbuf);
+ if(vsiz < 0) vsiz = strlen(vbuf);
+ if(!(path = crgetlobpath(curia, kbuf, ksiz))) return FALSE;
+ if(!crmklobdir(path)){
+ free(path);
+ return FALSE;
+ }
+ be = lstat(path, &sbuf) != -1 && S_ISREG(sbuf.st_mode);
+ mode = O_RDWR | O_CREAT;
+ if(dmode & CR_DKEEP) mode |= O_EXCL;
+ if(dmode & CR_DCAT){
+ mode |= O_APPEND;
+ } else {
+ mode |= O_TRUNC;
+ }
+ if((fd = open(path, mode, CR_FILEMODE)) == -1){
+ free(path);
+ dpecodeset(DP_EOPEN, __FILE__, __LINE__);
+ if(dmode == CR_DKEEP) dpecodeset(DP_EKEEP, __FILE__, __LINE__);
+ return FALSE;
+ }
+ free(path);
+ err = FALSE;
+ if(crwrite(fd, vbuf, vsiz) == -1){
+ err = TRUE;
+ dpecodeset(DP_EWRITE, __FILE__, __LINE__);
+ }
+ if(close(fd) == -1){
+ err = TRUE;
+ dpecodeset(DP_ECLOSE, __FILE__, __LINE__);
+ }
+ if(!err && !be) (curia->lrnum)++;
+ return err ? FALSE : TRUE;
+}
+
+
+/* Delete a large object. */
+int croutlob(CURIA *curia, const char *kbuf, int ksiz){
+ char *path;
+ int err, be;
+ struct stat sbuf;
+ assert(curia && kbuf);
+ if(!curia->wmode){
+ dpecodeset(DP_EMODE, __FILE__, __LINE__);
+ return FALSE;
+ }
+ if(ksiz < 0) ksiz = strlen(kbuf);
+ if(!(path = crgetlobpath(curia, kbuf, ksiz))) return FALSE;
+ be = lstat(path, &sbuf) != -1 && S_ISREG(sbuf.st_mode);
+ err = FALSE;
+ if(unlink(path) == -1){
+ err = TRUE;
+ dpecodeset(DP_ENOITEM, __FILE__, __LINE__);
+ }
+ free(path);
+ if(!err && be) (curia->lrnum)--;
+ return err ? FALSE : TRUE;
+}
+
+
+/* Retrieve a large object. */
+char *crgetlob(CURIA *curia, const char *kbuf, int ksiz, int start, int max, int *sp){
+ char *path, *buf;
+ struct stat sbuf;
+ int fd, size;
+ assert(curia && kbuf && start >= 0);
+ if(ksiz < 0) ksiz = strlen(kbuf);
+ if(!(path = crgetlobpath(curia, kbuf, ksiz))) return NULL;
+ if((fd = open(path, O_RDONLY, CR_FILEMODE)) == -1){
+ free(path);
+ dpecodeset(DP_ENOITEM, __FILE__, __LINE__);
+ return NULL;
+ }
+ free(path);
+ if(fstat(fd, &sbuf) == -1){
+ close(fd);
+ dpecodeset(DP_ESTAT, __FILE__, __LINE__);
+ return NULL;
+ }
+ if(start > sbuf.st_size){
+ close(fd);
+ dpecodeset(DP_ENOITEM, __FILE__, __LINE__);
+ return NULL;
+ }
+ if(lseek(fd, start, SEEK_SET) == -1){
+ close(fd);
+ dpecodeset(DP_ESEEK, __FILE__, __LINE__);
+ return NULL;
+ }
+ if(max < 0) max = sbuf.st_size;
+ if(!(buf = malloc(max + 1))){
+ close(fd);
+ dpecodeset(DP_EALLOC, __FILE__, __LINE__);
+ return NULL;
+ }
+ size = crread(fd, buf, max);
+ close(fd);
+ if(size == -1){
+ free(buf);
+ dpecodeset(DP_EREAD, __FILE__, __LINE__);
+ return NULL;
+ }
+ buf[size] = '\0';
+ if(sp) *sp = size;
+ return buf;
+}
+
+
+/* Get the file descriptor of a large object. */
+int crgetlobfd(CURIA *curia, const char *kbuf, int ksiz){
+ char *path;
+ int fd;
+ assert(curia && kbuf);
+ if(ksiz < 0) ksiz = strlen(kbuf);
+ if(!(path = crgetlobpath(curia, kbuf, ksiz))) return -1;
+ if((fd = open(path, curia->wmode ? O_RDWR: O_RDONLY, CR_FILEMODE)) == -1){
+ free(path);
+ dpecodeset(DP_ENOITEM, __FILE__, __LINE__);
+ return -1;
+ }
+ free(path);
+ return fd;
+}
+
+
+/* Get the size of the value of a large object. */
+int crvsizlob(CURIA *curia, const char *kbuf, int ksiz){
+ char *path;
+ struct stat sbuf;
+ assert(curia && kbuf);
+ if(ksiz < 0) ksiz = strlen(kbuf);
+ if(!(path = crgetlobpath(curia, kbuf, ksiz))) return -1;
+ if(lstat(path, &sbuf) == -1){
+ free(path);
+ dpecodeset(DP_ENOITEM, __FILE__, __LINE__);
+ return -1;
+ }
+ free(path);
+ return sbuf.st_size;
+}
+
+
+/* Get the number of the large objects stored in a database. */
+int crrnumlob(CURIA *curia){
+ assert(curia);
+ return curia->lrnum;
+}
+
+
+
+/*************************************************************************************************
+ * features for experts
+ *************************************************************************************************/
+
+
+/* Synchronize updating contents on memory. */
+int crmemsync(CURIA *curia){
+ int i, err;
+ assert(curia);
+ if(!curia->wmode){
+ dpecodeset(DP_EMODE, __FILE__, __LINE__);
+ return FALSE;
+ }
+ err = FALSE;
+ if(!dpput(curia->attr, CR_KEYLRNUM, -1, (char *)&(curia->lrnum), sizeof(int), DP_DOVER) ||
+ !dpmemsync(curia->attr)) err = TRUE;
+ for(i = 0; i < curia->dnum; i++){
+ if(!dpmemsync(curia->depots[i])){
+ err = TRUE;
+ break;
+ }
+ }
+ return err ? FALSE : TRUE;
+}
+
+
+/* Synchronize updating contents on memory, not physically. */
+int crmemflush(CURIA *curia){
+ int i, err;
+ assert(curia);
+ if(!curia->wmode){
+ dpecodeset(DP_EMODE, __FILE__, __LINE__);
+ return FALSE;
+ }
+ err = FALSE;
+ if(!dpput(curia->attr, CR_KEYLRNUM, -1, (char *)&(curia->lrnum), sizeof(int), DP_DOVER) ||
+ !dpmemsync(curia->attr)) err = TRUE;
+ for(i = 0; i < curia->dnum; i++){
+ if(!dpmemflush(curia->depots[i])){
+ err = TRUE;
+ break;
+ }
+ }
+ return err ? FALSE : TRUE;
+}
+
+
+/* Get flags of a database. */
+int crgetflags(CURIA *curia){
+ assert(curia);
+ return dpgetflags(curia->attr);
+}
+
+
+/* Set flags of a database. */
+int crsetflags(CURIA *curia, int flags){
+ assert(curia);
+ if(!curia->wmode){
+ dpecodeset(DP_EMODE, __FILE__, __LINE__);
+ return FALSE;
+ }
+ return dpsetflags(curia->attr, flags);
+}
+
+
+
+/*************************************************************************************************
+ * private objects
+ *************************************************************************************************/
+
+
+/* Get a copied string.
+ `str' specifies an original string.
+ The return value is a copied string whose region is allocated by `malloc'. */
+static char *crstrdup(const char *str){
+ int len;
+ char *buf;
+ assert(str);
+ len = strlen(str);
+ if(!(buf = malloc(len + 1))) return NULL;
+ memcpy(buf, str, len + 1);
+ return buf;
+}
+
+
+/* Get an integer from a database.
+ `depot' specifies an inner database handle.
+ `kbuf' specifies the pointer to the region of a key.
+ `ksiz' specifies the size of the key.
+ The return value is the integer of the corresponding record. */
+static int crdpgetnum(DEPOT *depot, const char *kbuf, int ksiz){
+ char *vbuf;
+ int vsiz, rv;
+ if(!(vbuf = dpget(depot, kbuf, ksiz, 0, -1, &vsiz)) || vsiz != sizeof(int)){
+ free(vbuf);
+ return INT_MIN;
+ }
+ rv = *(int *)vbuf;
+ free(vbuf);
+ return rv;
+}
+
+
+/* Get the path of a large object.
+ `curia' specifies a database handle.
+ `kbuf' specifies the pointer to the region of a key.
+ `ksiz' specifies the size of the key.
+ The return value is a path string whose region is allocated by `malloc'. */
+static char *crgetlobpath(CURIA *curia, const char *kbuf, int ksiz){
+ char prefix[CR_PATHBUFSIZ], *wp, *path;
+ int i, hash;
+ assert(curia && kbuf && ksiz >= 0);
+ wp = prefix;
+ wp += sprintf(wp, "%s%c%04d%c%s%c",
+ curia->name, MYPATHCHR, dpouterhash(kbuf, ksiz) % curia->dnum + 1,
+ MYPATHCHR, CR_LOBDIR, MYPATHCHR);
+ hash = dpinnerhash(kbuf, ksiz);
+ for(i = 0; i < CR_LOBDDEPTH; i++){
+ wp += sprintf(wp, "%02X%c", hash % 0x100, MYPATHCHR);
+ hash /= 0x100;
+ }
+ if(!(path = malloc(strlen(prefix) + ksiz * 2 + 1))){
+ dpecodeset(DP_EALLOC, __FILE__, __LINE__);
+ return NULL;
+ }
+ wp = path;
+ wp += sprintf(path, "%s", prefix);
+ for(i = 0; i < ksiz; i++){
+ wp += sprintf(wp, "%02X", ((unsigned char *)kbuf)[i]);
+ }
+ return path;
+}
+
+
+/* Create directories included in a path.
+ `path' specifies a path.
+ The return value is true if successful, else, it is false. */
+static int crmklobdir(const char *path){
+ char elem[CR_PATHBUFSIZ], *wp;
+ const char *dp;
+ int err, len;
+ wp = elem;
+ err = FALSE;
+ while(*path != '\0' && (dp = strchr(path, MYPATHCHR)) != NULL){
+ len = dp - path;
+ if((wp != elem || dp == path)) wp += sprintf(wp, "%c", MYPATHCHR);
+ memcpy(wp, path, len);
+ wp[len] = '\0';
+ wp += len;
+ if(mkdir(elem, CR_DIRMODE) == -1 && errno != EEXIST) err = TRUE;
+ path = dp + 1;
+ }
+ if(err) dpecodeset(DP_EMKDIR, __FILE__, __LINE__);
+ return err ? FALSE : TRUE;
+}
+
+
+/* Remove file and directories under a directory.
+ `path' specifies a path.
+ The return value is true if successful, else, it is false. */
+static int crrmlobdir(const char *path){
+ char elem[CR_PATHBUFSIZ];
+ DIR *DD;
+ struct dirent *dp;
+ assert(path);
+ if(unlink(path) != -1){
+ return TRUE;
+ } else {
+ if(errno == ENOENT) return TRUE;
+ if(!(DD = opendir(path))){
+ dpecodeset(DP_EMISC, __FILE__, __LINE__);
+ return FALSE;
+ }
+ while((dp = readdir(DD)) != NULL){
+ if(!strcmp(dp->d_name, MYCDIRSTR) || !strcmp(dp->d_name, MYPDIRSTR)) continue;
+ sprintf(elem, "%s%c%s", path, MYPATHCHR, dp->d_name);
+ if(!crrmlobdir(elem)){
+ closedir(DD);
+ return FALSE;
+ }
+ }
+ }
+ if(closedir(DD) == -1){
+ dpecodeset(DP_EMISC, __FILE__, __LINE__);
+ return FALSE;
+ }
+ if(rmdir(path) == -1){
+ dpecodeset(DP_ERMDIR, __FILE__, __LINE__);
+ return FALSE;
+ }
+ return TRUE;
+}
+
+
+/* Copy file and directories under a directory for repairing.
+ `path' specifies a path.
+ The return value is true if successful, else, it is false. */
+static int crcplobdir(CURIA *curia, const char *path){
+ char elem[CR_PATHBUFSIZ], numbuf[3], *rp, *kbuf, *vbuf;
+ DIR *DD;
+ struct dirent *dp;
+ struct stat sbuf;
+ int i, ksiz, vsiz, fd;
+ assert(curia && path);
+ if(lstat(path, &sbuf) == -1){
+ dpecodeset(DP_ESTAT, __FILE__, __LINE__);
+ return FALSE;
+ }
+ if(S_ISREG(sbuf.st_mode)){
+ rp = strrchr(path, MYPATHCHR) + 1;
+ for(i = 0; rp[i] != '\0'; i += 2){
+ numbuf[0] = rp[i];
+ numbuf[1] = rp[i+1];
+ numbuf[2] = '\0';
+ elem[i/2] = (int)strtol(numbuf, NULL, 16);
+ }
+ kbuf = elem;
+ ksiz = i / 2;
+ vsiz = sbuf.st_size;
+ if(!(vbuf = malloc(vsiz + 1))){
+ dpecodeset(DP_EALLOC, __FILE__, __LINE__);
+ return FALSE;
+ }
+ if((fd = open(path, O_RDONLY, CR_FILEMODE)) == -1){
+ free(vbuf);
+ dpecodeset(DP_EOPEN, __FILE__, __LINE__);
+ return FALSE;
+ }
+ if(crread(fd, vbuf, vsiz) == -1){
+ close(fd);
+ free(vbuf);
+ dpecodeset(DP_EOPEN, __FILE__, __LINE__);
+ return FALSE;
+ }
+ if(!crputlob(curia, kbuf, ksiz, vbuf, vsiz, DP_DOVER)){
+ close(fd);
+ free(vbuf);
+ return FALSE;
+ }
+ close(fd);
+ free(vbuf);
+ return TRUE;
+ }
+ if(!(DD = opendir(path))){
+ dpecodeset(DP_EMISC, __FILE__, __LINE__);
+ return FALSE;
+ }
+ while((dp = readdir(DD)) != NULL){
+ if(!strcmp(dp->d_name, MYCDIRSTR) || !strcmp(dp->d_name, MYPDIRSTR)) continue;
+ sprintf(elem, "%s%c%s", path, MYPATHCHR, dp->d_name);
+ if(!crcplobdir(curia, elem)){
+ closedir(DD);
+ return FALSE;
+ }
+ }
+ if(closedir(DD) == -1){
+ dpecodeset(DP_EMISC, __FILE__, __LINE__);
+ return FALSE;
+ }
+ return TRUE;
+}
+
+
+/* Write into a file.
+ `fd' specifies a file descriptor.
+ `buf' specifies a buffer to write.
+ `size' specifies the size of the buffer.
+ The return value is the size of the written buffer, or, -1 on failure. */
+static int crwrite(int fd, const void *buf, int size){
+ char *lbuf;
+ int rv, wb;
+ assert(fd >= 0 && buf && size >= 0);
+ lbuf = (char *)buf;
+ rv = 0;
+ do {
+ wb = write(fd, lbuf, size);
+ switch(wb){
+ case -1: if(errno != EINTR) return -1;
+ case 0: break;
+ default:
+ lbuf += wb;
+ size -= wb;
+ rv += wb;
+ break;
+ }
+ } while(size > 0);
+ return rv;
+}
+
+
+/* Read from a file and store the data into a buffer.
+ `fd' specifies a file descriptor.
+ `buffer' specifies a buffer to store into.
+ `size' specifies the size to read with.
+ The return value is the size read with, or, -1 on failure. */
+static int crread(int fd, void *buf, int size){
+ char *lbuf;
+ int i, bs;
+ assert(fd >= 0 && buf && size >= 0);
+ lbuf = buf;
+ for(i = 0; i < size && (bs = read(fd, lbuf + i, size - i)) != 0; i += bs){
+ if(bs == -1 && errno != EINTR) return -1;
+ }
+ return i;
+}
+
+
+
+/* END OF FILE */
generated by cgit v1.2.3 (git 2.25.1) at 2024-04-25 04:27:38 +0000