hash_ops.c

Go to the documentation of this file.

/************************************************************************
 * Copyright (C) 2007-2008 Philipp Marek.
 *
 * This program is free software;  you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 3 as
 * published by the Free Software Foundation.
 ************************************************************************/

#include <fcntl.h>

#include "global.h"
#include "waa.h"
#include "helper.h"
#include "hash_ops.h"


int hsh___new_bare(char *wcfile, char *name, int gdbm_mode, 
        GDBM_FILE *output, 
        char **fname_out)
{
    int status;
    char *cp, *eos;
    GDBM_FILE db;


    status=0;
    db=NULL;

    if (gdbm_mode == HASH_TEMPORARY)
    {
        cp=waa_tmp_path;
        /* Use this bit, so that the open filehandle says what it was. */
        eos=waa_tmp_fn;
    }
    else
        STOPIF( waa__get_waa_directory(wcfile, &cp, &eos, NULL,
                    ( (gdbm_mode == GDBM_READER) ? 0 : GWD_MKDIR)  
                    | waa__get_gwd_flag(name)), NULL);
    strcpy(eos, name);

    if (gdbm_mode == GDBM_NEWDB || gdbm_mode == HASH_TEMPORARY)
    {
        /* libgdbm3=1.8.3-3 has a bug - with GDBM_NEWDB an existing database is 
         * not truncated. Only the O_CREAT, not the O_TRUNC flag is used.
         * debian #447981. */
        /* No error, and ENOENT are both ok. */
        STOPIF_CODE_ERR( (unlink(cp) == -1) && (errno != ENOENT), errno,
                "Removing database file '%s'", cp);
        status=0;
    }

    db = gdbm_open(cp, 0, gdbm_mode, 0777, NULL);
    if (!db)
    {
        status=errno;
        if (status != ENOENT)
            STOPIF(status, "Cannot open database file %s", cp);
    }
    else
    {
        /* Temporary files can be removed immediately. */
        if (gdbm_mode == HASH_TEMPORARY)
            STOPIF_CODE_ERR( unlink(cp) == -1, errno,
                    "Removing database file '%s'", cp);

        if (fname_out) 
            STOPIF( hlp__strdup( fname_out, cp), NULL);
    }

ex:
    if (status)
    {
        if (db) gdbm_close(db);
    }
    else
        *output=db;

    return status;
}


int hsh__new(char *wcfile, char *name, int gdbm_mode, 
        hash_t *output)
{
    int status;
    hash_t hash;


    STOPIF( hlp__calloc( &hash, 1, sizeof(*hash)), NULL);

    /* Return errors silently. */
    status=hsh___new_bare(wcfile, name, 
            gdbm_mode & ~HASH_REMEMBER_FILENAME, 
            & (hash->db), 
            gdbm_mode & HASH_REMEMBER_FILENAME ? &(hash->filename) : NULL);

ex:
    if (status)
        IF_FREE(hash);
    else
        *output=hash;

    return status;
}


int hsh__collect_garbage(hash_t db, int *did_remove)
{
    int status;
    int have_removed;
    datum key, next;

    status=0;
    have_removed=0;
    if (db && db->to_delete)
    {
        key=gdbm_firstkey(db->to_delete);
        while (key.dptr)
        {
            next=gdbm_nextkey(db->to_delete, key);
            STOPIF_CODE_ERR( gdbm_delete(db->db, key)!=0, gdbm_errno,
                    "Removing entry");

            free(key.dptr);
            key=next;
            have_removed++;
        }

        DEBUGP("%d cleanups", have_removed);

        gdbm_close(db->to_delete);
        db->to_delete=NULL;
    }

    if (did_remove) *did_remove=have_removed;

ex:
    return status;
}


int hsh__close(hash_t db, int has_failed)
{
    int status;
    int have_removed;
    datum key;


    status=0;
    if (!db) goto ex;

    have_removed=0;
    if (db->to_delete)
    {
        if (!has_failed)
            STOPIF( hsh__collect_garbage(db, &have_removed), NULL);
    }

    /* No more data in that hash? */
    if (hsh__first(db, &key) == ENOENT &&
            db->filename)
    {
        DEBUGP("nothing found, removing %s", db->filename);
        STOPIF( waa__delete_byext(db->filename, NULL, 0), 
                "Cleaning up the empty hash '%s'", db->filename);
    }
    else
    {
        DEBUGP("reorganize?");
        /* At least fewer space used? */
        if (have_removed)
            gdbm_reorganize(db->db);
    }

    DEBUGP("closing hash");
    /* It's possible that some hash was never opened, because there was no 
     * need to. */
    if (db->db)
    {
        gdbm_close(db->db);
        db->db=NULL;
    }

ex:
    if (db)
        IF_FREE(db->filename);
    IF_FREE(db);

    return status;
}


int hsh__fetch(hash_t db, datum key, datum *value)
{
    static datum vl;

    if (!db) return ENOENT;

    vl=gdbm_fetch(db->db, key);

    if (value) *value=vl;
    else IF_FREE(vl.dptr);
    return (vl.dptr) ? 0 : ENOENT;
}


int hsh__first(hash_t db, datum *key)
{
    datum k;

    if (!db) return ENOENT;

    k=gdbm_firstkey(db->db);
    if (key) *key=k;
    return (k.dptr) ? 0 : ENOENT;
}


int hsh__next(hash_t db, datum *key, const datum *oldkey)
{
    datum k;

    /* Get next key. */
    k=gdbm_nextkey(db->db, *oldkey);

    /* Ev. free old key-data. */
    if (oldkey == key) 
        /* Should be IF_FREE(oldkey->dptr) -- but oldkey==key, and oldkey is 
         * read-only. */
        IF_FREE(key->dptr);

    /* Return new key. */
    *key=k;

    return (k.dptr) ? 0 : ENOENT;
}


int hsh__store(hash_t db, datum key, datum value)
{
    int status;

    if (value.dsize == 0 || value.dptr == NULL)
        status=gdbm_delete(db->db, key);
    else
        status=gdbm_store(db->db, key, value, GDBM_REPLACE);

    STOPIF_CODE_ERR(status < 0, errno,
            "Error writing property %s", key.dptr);

ex:
    return status;
}


int hsh__store_charp(hash_t db, char *keyp, char *valuep)
{   
    datum key, value;

    key.dptr=keyp;
    value.dptr=valuep;

    key.dsize=strlen(key.dptr)+1;
    value.dsize=strlen(value.dptr)+1;

    return hsh__store(db, key, value);
}

struct hsh___list
{
    int count;
    void *entries[HASH__LIST_MAX];
};


int hsh__insert_pointer(hash_t hash, datum key, void *value)
{
    int status;
    datum listd;
    struct hsh___list list, *dst;

    status=hsh__fetch(hash, key, &listd);
    if (status == ENOENT)
    {
        /* None found. */
        /* Don't know why this is not a (void*) ... possibly because it 
         * couldn't add up :-) */
        listd.dptr= (char*)&list;
        listd.dsize=sizeof(list);

        memset(&list, 0, sizeof(list));
        list.count=1;
        list.entries[0]=value;

        status=0;
    }
    else
    {
        /* Already something there. We can re-use the storage, as it was 
         * malloc()ed anyway. */
        BUG_ON(listd.dsize != sizeof(list));

        /* status is still 0, so per default the list would get written. */
        dst=(struct hsh___list*)listd.dptr;
        if (dst->count == HASH__LIST_MAX)
        {
            /* On dst->count reaching MAX_DUPL_ENTRIES we have to write the 
             * structure once again. */
            /* Later we could avoid it ... although it 
                 might be interesting how many there are. Maybe even resizing? */
            dst->count++;
        }
        else if (dst->count > HASH__LIST_MAX)
        {
            /* No more writes needed. */
            status=EFBIG;
        }
        else
        {
            /* Normal operation, still space available. */
            dst->entries[ dst->count ] = value;
            dst->count++;
        }
    }

    if (status != EFBIG)
        STOPIF( hsh__store(hash, key, listd), NULL);

ex:
    return status;
}


int hsh__list_get(hash_t hash, 
        datum current_key, datum *next_key, 
        struct estat **arr[], int *found)
{
    int status;
    /* We ensure at least a single NULL at the end. */
    static struct estat *data[HASH__LIST_MAX+1];
    datum value;
    struct hsh___list *list;
    int c;


    status=0;
    *found=0;
    *arr=NULL;
    /* No next key ... we return the array. */
    if (next_key) 
    {
        next_key->dsize=0;
        next_key->dptr=0;
    }

    status=hsh__fetch( hash, current_key, &value);
    /* Nothing here? Just report that. */
  if (status == ENOENT) goto ex;
    STOPIF(status, NULL);

    list=(struct hsh___list*)value.dptr;

    memset(data, 0, sizeof(data));

    c=list->count;
    /* Overflow? */
    if (c == HASH__LIST_MAX+1) c=HASH__LIST_MAX;

    BUG_ON( c<=0 || c>HASH__LIST_MAX, "number of entries=%d", c);
    memcpy(data, list->entries, c*sizeof(data[0]));

    *found=c;
    *arr=data;

ex:
    return status;
}


int hsh__register_delete(hash_t db, datum key)
{
    int status;
    const datum data= { .dsize=1, .dptr="\0", };

    status=0;

    if (!db->to_delete)
    {
        STOPIF( hsh___new_bare(NULL, "del", HASH_TEMPORARY,
                    &(db->to_delete), NULL), 
                NULL);
    }

    DEBUGP("storing %s", key.dptr);

    status=gdbm_store(db->to_delete, key, data, GDBM_REPLACE);
    STOPIF_CODE_ERR(status < 0, errno, "Error writing key");

ex:
    return status;
}

---