~ubuntu-branches/ubuntu/trusty/bmf/trusty

/* $Id: dbdb.c,v 1.22 2002/10/19 09:59:35 tommy Exp $ */

/*

 * Copyright (c) 2002 Tom Marshall <tommy@tig-grr.com>

 *

 * This program is free software.  It may be distributed under the terms

 * in the file LICENSE, found in the top level of the distribution.

 *

 * dbdb.c: berkeley database handler

 */

#include "config.h"

#include "dbg.h"

#include "str.h"

#include "lex.h"

#include "vec.h"

#include "dbh.h"

#include "dbdb.h"

#ifdef HAVE_LIBDB

#define DBT_init( pdbt ) memset( pdbt, 0, sizeof(DBT) )

#if !defined(DB_VERSION_MAJOR) /* v1 */

#define dbx_get(dbp,kp,vp)  dbp->get( dbp, kp, vp, 0 )

#define dbx_put(dbp,kp,vp)  dbp->put( dbp, kp, vp, 0 )

#define dbx_fd(dbp,fd)      fd = dbp->fd( dbp )

#else /* v2+ */

#define dbx_get(dbp,kp,vp)  dbp->get( dbp, NULL, kp, vp, 0 )

#define dbx_put(dbp,kp,vp)  dbp->put( dbp, NULL, kp, vp, 0 )

#define dbx_fd(dbp,fd)      dbp->fd( dbp, &fd )

#endif /* DB_VERSION_MAJOR */

#if !defined(DB_VERSION_MAJOR) /* v1 */

typedef DB DBC; /* no separate cursor type */

#define dbx_createcursor(dbp,dbcp)  ((dbcp = dbp) ? 0 : -1)

#define dbx_destroycursor(dbcp)     (dbcp = NULL)

#define dbx_first(dbcp,kp,vp)       dbcp->seq(dbcp,kp,vp,R_FIRST)

#define dbx_next(dbcp,kp,vp)        dbcp->seq(dbcp,kp,vp,R_NEXT)

#define dbx_prev(dbcp,kp,vp)        dbcp->seq(dbcp,kp,vp,R_PREV)

#define dbx_last(dbcp,kp,vp)        dbcp->seq(dbcp,kp,vp,R_LAST)

#elif DB_VERSION_MAJOR == 2

#define dbx_createcursor(dbp,dbcp)  dbp->cursor(dbp,NULL,&csrp)

#define dbx_destroycursor(dbcp)     dbcp->c_close(dbcp)

#define dbx_first(dbcp,kp,vp)       dbcp->c_get(dbcp,kp,vp,DB_FIRST)

#define dbx_next(dbcp,kp,vp)        dbcp->c_get(dbcp,kp,vp,DB_NEXT)

#define dbx_prev(dbcp,kp,vp)        dbcp->c_get(dbcp,kp,vp,DB_PREV)

#define dbx_last(dbcp,kp,vp)        dbcp->c_get(dbcp,kp,vp,DB_LAST)

#else /* v3+ */

#define dbx_createcursor(dbp,dbcp)  dbp->cursor(dbp,NULL,&csrp,0)

#define dbx_destroycursor(dbcp)     dbcp->c_close(dbcp)

#define dbx_first(dbcp,kp,vp)       dbcp->c_get(dbcp,kp,vp,DB_FIRST)

#define dbx_next(dbcp,kp,vp)        dbcp->c_get(dbcp,kp,vp,DB_NEXT)

#define dbx_prev(dbcp,kp,vp)        dbcp->c_get(dbcp,kp,vp,DB_PREV)

#define dbx_last(dbcp,kp,vp)        dbcp->c_get(dbcp,kp,vp,DB_LAST)

#endif /* DB_VERSION_MAJOR */

static void char2DBT( DBT* pdbt, char* p )

{

    pdbt->data = p;

    pdbt->size = strlen(p);

}

static void uint2DBT( DBT* pdbt, uint* p )

{

    pdbt->data = p;

    pdbt->size = sizeof(uint);

}

static uint DBT2uint( DBT* pdbt )

{

    uint n;

    memcpy( &n, pdbt->data, sizeof(n) );

    return n;

}

dbh_t* dbdb_db_open( cpchar dbhost, cpchar dbname, cpchar dbuser, cpchar dbpass )

{

    dbhdb_t*    pthis;

    uint        dirlen;

    cpchar      phome;

    struct stat st;

    pthis = (dbhdb_t*)malloc( sizeof(dbhdb_t) );

    if( pthis == NULL )

    {

        goto bail;

    }

    pthis->close = dbdb_db_close;

    pthis->opentable = dbdb_db_opentable;

    if( dbname != NULL && *dbname != '\0' )

    {

        dirlen = strlen( dbname );

        pthis->dir = strdup( dbname );

        if( pthis->dir[dirlen-1] == '/' )

        {

            pthis->dir[dirlen-1] = '\0';

        }

    }

    else

    {

        phome = getenv( "HOME" );

        if( phome == NULL || *phome == '\0' )

        {

            phome = ".";

        }

        pthis->dir = (char*)malloc( strlen(phome)+5+1 );

        if( pthis->dir == NULL )

        {

            goto bail;

        }

        sprintf( pthis->dir, "%s/.bmf", phome );

    }

    /* ensure config directory exists */

    if( stat( pthis->dir, &st ) != 0 )

    {

        if( errno == ENOENT )

        {

            if( mkdir( pthis->dir, S_IRUSR|S_IWUSR|S_IXUSR ) != 0 )

            {

                goto bail;

            }

        }

        else

        {

            goto bail;

        }

    }

    else

    {

        if( !S_ISDIR( st.st_mode ) )

        {

            goto bail;

        }

    }

#if !defined(DB_VERSION_MAJOR) || DB_VERSION_MAJOR < 3

    /* no initialization */

#else /* DB_VERSION_MAJOR >= 3 */

    if( db_env_create( &pthis->envp, 0 ) != 0 )

    {

        goto bail;

    }

    if( pthis->envp->open( pthis->envp, pthis->dir, DB_INIT_LOCK|DB_INIT_MPOOL|DB_CREATE, 0644 ) != 0 )

    {

        goto bail;

    }

#endif /* DB_VERSION_MAJOR */

    return (dbh_t*)pthis;

bail:

    free( pthis );

    return NULL;

}

bool_t dbdb_db_close( dbhdb_t* pthis )

{

#if !defined(DB_VERSION_MAJOR) || DB_VERSION_MAJOR < 3

    /* no cleanup */

#else /* DB_VERSION_MAJOR >= 3 */

    pthis->envp->close( pthis->envp, 0 );

#endif /* DB_VERSION_MAJOR */

    free( pthis->dir );

    pthis->dir = NULL;

    return true;

}

dbt_t* dbdb_db_opentable( dbhdb_t* pthis, cpchar table, bool_t rdonly )

{

    dbtdb_t*    ptable;

    DB*         dbp;

    DBT         key;

    DBT         val;

    char        szpath[PATH_MAX];

    ptable = (dbtdb_t*)malloc( sizeof(dbtdb_t) );

    if( ptable == NULL )

    {

        return NULL;

    }

    ptable->close = dbdb_table_close;

    ptable->mergeclose = dbdb_table_mergeclose;

    ptable->unmergeclose = dbdb_table_unmergeclose;

    ptable->import = dbdb_table_import;

    ptable->export = dbdb_table_export;

    ptable->getmsgcount = dbdb_table_getmsgcount;

    ptable->getcount = dbdb_table_getcount;

    ptable->dbp = NULL;

    sprintf( szpath, "%s/%s.db", pthis->dir, table );

#if !defined(DB_VERSION_MAJOR)

    if( (dbp = dbopen( szpath, O_CREAT|O_RDWR, 0644, DB_BTREE, NULL)) == NULL )

    {

        goto bail;

    }

#elif DB_VERSION_MAJOR == 2

    if( db_open( szpath, DB_BTREE, DB_CREATE, 0644, NULL, NULL, &dbp ) != 0 )

    {

        goto bail;

    }

#elif (DB_VERSION_MAJOR == 3) || (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR == 0)

    ptable->envp = pthis->envp;

    if( db_create( &dbp, NULL, 0 ) != 0 )

    {

        goto bail;

    }

    if( dbp->open( dbp, szpath, NULL, DB_BTREE, DB_CREATE, 0644 ) != 0 )

    {

        goto bail;

    }

#else /* v4.1+ */

    ptable->envp = pthis->envp;

    if( db_create( &dbp, NULL, 0 ) != 0 )

    {

        goto bail;

    }

    if( dbp->open( dbp, NULL, szpath, NULL, DB_BTREE, DB_CREATE, 0644 ) != 0 )

    {

        goto bail;

    }

#endif /* DB_VERSION_MAJOR */

    ptable->dbp = dbp;

    DBT_init( &key );

    DBT_init( &val );

    ptable->nmsgs = 0;

    char2DBT( &key, MSGCOUNT_KEY );

    if( dbx_get( dbp, &key, &val ) == 0 )

    {

        ptable->nmsgs = DBT2uint( &val );

    }

    return (dbt_t*)ptable;

bail:

    free( ptable );

    return NULL;

}

static bool_t dbdb_table_lock( dbtdb_t* pthis )

{

#ifndef NOLOCK

    struct flock lock;

    int fd;

    dbx_fd( pthis->dbp, fd );

    memset( &lock, 0, sizeof(lock) );

    lock.l_type = F_WRLCK;

    lock.l_start = 0;

    lock.l_whence = SEEK_SET;

    lock.l_len = 0;

    if( fcntl( fd, F_SETLKW, &lock ) != 0 )

    {

        return false;

    }

#endif /* ndef NOLOCK */

    return true;

}

static bool_t dbdb_table_unlock( dbtdb_t* pthis )

{

#ifndef NOLOCK

    struct flock lock;

    int fd;

    dbx_fd( pthis->dbp, fd );

    memset( &lock, 0, sizeof(lock) );

    lock.l_type = F_UNLCK;

    lock.l_start = 0;

    lock.l_whence = SEEK_SET;

    lock.l_len = 0;

    if( fcntl( fd, F_SETLK, &lock ) != 0 )

    {

        return false;

    }

#endif /* ndef NOLOCK */

    return true;

}

bool_t dbdb_table_close( dbtdb_t* pthis )

{

    DB* dbp = pthis->dbp;

    if( dbp != NULL )

    {

#if !defined(DB_VERSION_MAJOR) /* v1 */

        dbp->close( dbp );

#else /* v2+ */

        dbp->close( dbp, 0 );

#endif /* DB_VERSION_MAJOR */

        pthis->dbp = NULL;

    }

    return true;

}

bool_t dbdb_table_mergeclose( dbtdb_t* pthis, vec_t* pmsg )

{

    DB*         dbp = pthis->dbp;

    DBT         key;

    DBT         val;

    char        szword[MAXWORDLEN+1];

    uint        count;

    veciter_t   msgiter;

    str_t*      pmsgstr;

    if( pthis->dbp == NULL )

    {

        return false;

    }

    if( !dbdb_table_lock( pthis ) )

    {

        return false;

    }

    pthis->nmsgs++;

    DBT_init( &key );

    DBT_init( &val );

    char2DBT( &key, MSGCOUNT_KEY );

    uint2DBT( &val, &pthis->nmsgs );

    dbx_put( dbp, &key, &val );

    vec_first( pmsg, &msgiter );

    pmsgstr = veciter_get( &msgiter );

    while( pmsgstr != NULL )

    {

        assert( pmsgstr->len <= MAXWORDLEN );

        strncpylwr( szword, pmsgstr->p, pmsgstr->len );

        szword[pmsgstr->len] = '\0';

        count = db_getnewcount( &msgiter );

        char2DBT( &key, szword );

        if( dbx_get( dbp, &key, &val ) == 0 )

        {

            count += DBT2uint( &val );

        }

        char2DBT( &key, szword );

        uint2DBT( &val, &count );

        if( dbx_put( dbp, &key, &val ) != 0 )

        {

            goto bail;

        }

        veciter_next( &msgiter );

        pmsgstr = veciter_get( &msgiter );

    }

    veciter_destroy( &msgiter );

    dbdb_table_unlock( pthis );

    return dbdb_table_close( pthis );

bail:

    return false;

}

bool_t dbdb_table_unmergeclose( dbtdb_t* pthis, vec_t* pmsg )

{

    DB*         dbp = pthis->dbp;

    DBT         key;

    DBT         val;

    char        szword[MAXWORDLEN+1];

    uint        count;

    veciter_t   msgiter;

    str_t*      pmsgstr;

    if( pthis->dbp == NULL )

    {

        return false;

    }

    if( pthis->nmsgs > 0 )

    {

        pthis->nmsgs--;

    }

    if( !dbdb_table_lock( pthis ) )

    {

        return false;

    }

    DBT_init( &key );

    DBT_init( &val );

    char2DBT( &key, MSGCOUNT_KEY );

    uint2DBT( &val, &pthis->nmsgs );

    dbx_put( dbp, &key, &val );

    vec_first( pmsg, &msgiter );

    pmsgstr = veciter_get( &msgiter );

    while( pmsgstr != NULL )

    {

        assert( pmsgstr->len <= MAXWORDLEN );

        strncpylwr( szword, pmsgstr->p, pmsgstr->len );

        szword[pmsgstr->len] = '\0';

        count = db_getnewcount( &msgiter );

        char2DBT( &key, szword );

        if( dbx_get( dbp, &key, &val ) == 0 )

        {

            uint n = DBT2uint( &val );

            n = (n > count) ? (n - count) : 0;

            char2DBT( &key, szword );

            uint2DBT( &val, &n );

            if( dbx_put( dbp, &key, &val ) != 0 )

            {

                goto bail;

            }

        }

        veciter_next( &msgiter );

        pmsgstr = veciter_get( &msgiter );

    }

    veciter_destroy( &msgiter );

    dbdb_table_unlock( pthis );

    return dbdb_table_close( pthis );

bail:

    return false;

}

bool_t dbdb_table_import( dbtdb_t* pthis, cpchar filename )

{

    DB* dbp = pthis->dbp;

    int fd;

    struct stat st;

    char* pbuf;

    char* pbegin;

    char* pend;

    rec_t r;

    DBT key;

    DBT val;

    char szword[MAXWORDLEN+1];

    if( pthis->dbp == NULL )

    {

        return false;

    }

    if( (fd = open( filename, O_RDONLY, 0644 )) < 0 )

    {

        return false;

    }

    if( fstat( fd, &st ) != 0 )

    {

        goto bail;

    }

    if( st.st_size == 0 )

    {

        goto bail;

    }

    pbuf = (char*)malloc( st.st_size );

    if( pbuf == NULL )

    {

        goto bail;

    }

    if( read( fd, pbuf, st.st_size ) != st.st_size )

    {

        goto bail;

    }

    DBT_init( &key );

    DBT_init( &val );

    if( sscanf( pbuf, BOGOFILTER_HEADER, &pthis->nmsgs ) != 1 )

    {

        goto bail;

    }

    pbegin = pbuf;

    while( *pbegin != '\n' ) pbegin++;

    pbegin++;

    char2DBT( &key, MSGCOUNT_KEY );

    uint2DBT( &val, &pthis->nmsgs );

    if( dbx_put( dbp, &key, &val ) != 0 )

    {

        goto bail;

    }

    while( pbegin < pbuf + st.st_size )

    {

        pend = pbegin;

        r.w.p = pbegin;

        r.w.len = 0;

        r.n = 0;

        while( *pend != '\n' )

        {

            if( pend >= pbuf + st.st_size )

            {

                goto bail;

            }

            *pend = tolower(*pend);

            if( *pend == ' ' )

            {

                r.w.len = (pend-pbegin);

                r.n = strtol( pend+1, NULL, 10 );

            }

            pend++;

        }

        if( pend > pbegin && *pbegin != '#' && *pbegin != ';' )

        {

            if( r.w.len == 0 || r.w.len > MAXWORDLEN )

            {

                fprintf( stderr, "dbh_loadfile: bad file format\n" );

                goto bail;

            }

            strncpylwr( szword, r.w.p, r.w.len );

            szword[r.w.len] = '\0';

            char2DBT( &key, szword );

            uint2DBT( &val, &r.n );

            if( dbx_put( dbp, &key, &val ) != 0 )

            {

                goto bail;

            }

        }

        pbegin = pend+1;

    }

    free( pbuf );

    close( fd );

    return true;

bail:

    return false;

}

bool_t dbdb_table_export( dbtdb_t* pthis, cpchar filename )

{

    DB*     dbp = pthis->dbp;

    int     fd;

    char    iobuf[IOBUFSIZE];

    char*   p;

    DBC*    csrp;

    int     rc;

    DBT     key;

    DBT     val;

    if( (fd = open( filename, O_CREAT|O_WRONLY|O_TRUNC, 0644 )) < 0 )

    {

        goto bail;

    }

    if( dbx_createcursor( dbp, csrp ) != 0 )

    {

        goto bail;

    }

    DBT_init( &key );

    DBT_init( &val );

    p = iobuf;

    p += sprintf( p, BOGOFILTER_HEADER, pthis->nmsgs );

    rc = dbx_first( csrp, &key, &val );

    while( rc == 0 )

    {

        assert( key.data != NULL && key.size <= MAXWORDLEN );

        assert( val.data != NULL && val.size == sizeof(uint) );

        if( key.size != MSGCOUNT_KEY_LEN ||

            memcmp( key.data, MSGCOUNT_KEY, MSGCOUNT_KEY_LEN ) != 0 )

        {

            memcpy( p, key.data, key.size ); p += key.size;

            *p++ = ' ';

            p += sprintf( p, "%u\n", DBT2uint(&val) );

            if( p+TEXTDB_MAXLINELEN > (iobuf+1) )

            {

                write( fd, iobuf, p-iobuf );

                p = iobuf;

            }

        }

        rc = dbx_next( csrp, &key, &val );

    }

    dbx_destroycursor( csrp );

    if( p != iobuf )

    {

        write( fd, iobuf, p-iobuf );

    }

    close( fd );

    return true;

bail:

    return false;

}

uint dbdb_table_getmsgcount( dbtdb_t* pthis )

{

    return pthis->nmsgs;

}

uint dbdb_table_getcount( dbtdb_t* pthis, str_t* pword )

{

    DB*         dbp = pthis->dbp;

    DBT         key;

    DBT         val;

    char szword[MAXWORDLEN+1];

    uint count = 0;

    assert( pword->len <= MAXWORDLEN );

    strncpylwr( szword, pword->p, pword->len );

    szword[pword->len] = '\0';

    count = 0;

    DBT_init( &key );

    DBT_init( &val );

    char2DBT( &key, szword );

    if( dbx_get( dbp, &key, &val ) == 0 )

    {

        count = DBT2uint( &val );

    }

    return count;

}

#else /* def HAVE_LIBDB */

dbh_t* dbdb_db_open( cpchar dbhost, cpchar dbname, cpchar dbuser, cpchar dbpass )

{

    return NULL;

}

#endif /* def HAVE_LIBDB */

#ifdef UNIT_TEST

int main( int argc, char** argv )

{

    dbh_t*      pdb;

    veciter_t   iter;

    str_t*      pstr;

    uint        n;

    if( argc != 2 )

    {

        fprintf( stderr, "usage: %s <file>\n", argv[0] );

        return 1;

    }

    for( n = 0; n < 100; n++ )

    {

        pdb = dbh_open( "testlist", true );

        vec_first( &db, &iter );

        while( (pstr = veciter_get( &iter )) != NULL )

        {

            char  buf[MAXWORDLEN+32];

            char* p;

            if( pstr->len > 200 )

            {

                fprintf( stderr, "str too long: %u chars\n", pstr->len );

                break;

            }

            p = buf;

            strcpy( buf, "str: " );

            p += 6;

            memcpy( p, pstr->p, pstr->len );

            p += pstr->len;

            sprintf( p, " %u", pstr->count );

            puts( buf );

            veciter_next( &iter );

        }

        dbh_close( &db );

    }

    return 0;

}

#endif /* def UNIT_TEST */