Updated to current mtstdopen interface.

[statserve.git] / dbsrc.c

#include <stdlib.h>
#include <stdio.h>
#include <db.h>
#include <string.h>
#include <ashd/utils.h>
#include <ashd/log.h>
#include <time.h>

#include "statserve.h"

struct dbsrc {
    char *envnm;
    DB_ENV *env;
    DB *db;
    time_t lastcp, lastar;
};

int dbpagesize = 0;

static struct fileinfo dbserve(struct source *src, char *nm)
{
    struct dbsrc *d = src->pdata;
    int i, ret, ver;
    DBT k, v;
    size_t sz;
    void *hp, *p;
    struct fileinfo retf;
    
    memset(&k, 0, sizeof(k));
    memset(&v, 0, sizeof(v));
    k.size = strlen(k.data = nm);
    v.flags = DB_DBT_MALLOC;
    do {
	ret = d->db->get(d->db, NULL, &k, &v, 0);
    } while(ret == DB_LOCK_DEADLOCK);
    if(ret == 0) {
	hp = v.data;
	sz = v.size;
	if(sz < 1)
	    goto corrupt;
	ver = *(uint8_t *)hp;
	hp++; sz--;
	if(ver == 1) {
	    if(sz < 8)
		goto corrupt;
	    memset(&retf, 0, sizeof(retf));
	    for(i = 0, retf.mtime = 0; i < 8; i++) {
		retf.mtime = (retf.mtime << 8) | (*(uint8_t *)hp);
		hp++; sz--;
	    }
	    if(retf.mtime < 0)
		goto corrupt;
	    if((p = memchr(hp, 0, sz)) == NULL)
		goto corrupt;
	    p++;
	    if(p - hp > 64)
		goto corrupt;
	    strcpy(retf.ctype, hp);
	    sz -= p - hp; hp = p;
	    retf.data = memcpy(smalloc(retf.sz = sz), hp, sz);
	    free(v.data);
	    return(retf);
	} else {
	    goto corrupt;
	}
    } else if(ret == DB_NOTFOUND) {
	return((struct fileinfo){});
    } else {
	flog(LOG_ERR, "could not read value of %s in %s: %s", nm, d->envnm, db_strerror(ret));
	return((struct fileinfo){});
    }
    goto out;

corrupt:
    flog(LOG_ERR, "entry for %s in %s is corrupted", nm, d->envnm);
    free(v.data);
    return((struct fileinfo){});
out:;
}

static void dbidle(struct source *src)
{
    struct dbsrc *d = src->pdata;
    time_t now;
    int ret;
    char **files;
    
    now = time(NULL);
    if(now - d->lastcp > 1800) {
	d->lastcp = now;
	if((ret = d->env->txn_checkpoint(d->env, 5000, 0, 0)) != 0) {
	    flog(LOG_ERR, "could not make db checkpoint in %s: %s", d->envnm, db_strerror(ret));
	}
    }
    if(now - d->lastar > 7200) {
	d->lastar = now;
	files = NULL;
	if((ret = d->env->log_archive(d->env, &files, DB_ARCH_REMOVE)) != 0) {
	    flog(LOG_ERR, "could not archive log files in %s: %s", d->envnm, db_strerror(ret));
	}
	if(files != NULL)
	    free(files);
    }
}

static void dbclose(struct source *src)
{
    struct dbsrc *d = src->pdata;
    
    d->db->close(d->db, 0);
    d->env->close(d->env, 0);
}

static void enverror(const DB_ENV *env, const char *prefix, const char *msg)
{
    flog(LOG_ERR, "dbsource: environment error: %s", msg);
}

struct source *mkdbsrc(char *path, char *envpath)
{
    struct source *src;
    struct dbsrc *d;
    char *p;
    int ret;
    
    omalloc(src);
    src->serve = dbserve;
    src->idle = dbidle;
    src->close = dbclose;
    src->pdata = omalloc(d);
    if((ret = db_env_create(&d->env, 0)) != 0) {
	flog(LOG_ERR, "could not create bdb environment: %s", db_strerror(ret));
	goto fail;
    }
    if(envpath) {
	d->envnm = sstrdup(envpath);
    } else {
	d->envnm = sstrdup(path);
	if((p = strrchr(d->envnm, '/')) == NULL) {
	    free(d->envnm);
	    d->envnm = sstrdup(".");
	} else {
	    *p = 0;
	}
    }
    if((ret = d->env->open(d->env, d->envnm, DB_CREATE | DB_INIT_MPOOL | DB_INIT_LOCK | DB_INIT_LOG | DB_INIT_TXN, 0666)) != 0) {
	flog(LOG_ERR, "could not open bdb environment: %s", db_strerror(ret));
	goto fail;
    }
    d->env->set_lk_detect(d->env, DB_LOCK_RANDOM);
    d->env->set_errcall(d->env, enverror);
    if((ret = db_create(&d->db, d->env, 0)) != 0) {
	flog(LOG_ERR, "could not create bdb database: %s", db_strerror(ret));
	goto fail;
    }
    if(dbpagesize) {
	if((ret = d->db->set_pagesize(d->db, dbpagesize)) != 0) {
	    flog(LOG_ERR, "could not set bdb page size (to %i): %s", dbpagesize, db_strerror(ret));
	    goto fail;
	}
    }
    if((ret = d->db->open(d->db, NULL, path, NULL, DB_HASH, DB_AUTO_COMMIT | DB_CREATE, 0666)) != 0) {
	flog(LOG_ERR, "could not open bdb database: %s", db_strerror(ret));
	goto fail;
    }
    return(src);
    
fail:
    if(d->db)
	d->db->close(d->db, 0);
    if(d->env)
	d->env->close(d->env, 0);
    free(d);
    free(src);
    return(NULL);
}