Git Repositories

Store metadata in GVFS's daemon.
authorNick Schermer <nick@xfce.org>
Wed, 26 Sep 2012 21:29:42 +0000 (23:29 +0200)
committerNick Schermer <nick@xfce.org>
Wed, 26 Sep 2012 21:29:42 +0000 (23:29 +0200)
We already require GVFS for a trash implementation, so
why ot rely on the metadata storage too.

22 files changed:
.gitignore
AUTHORS
FAQ
Makefile.am
configure.in.in
po/POTFILES.skip
tdb/Makefile.am [deleted file]
tdb/README [deleted file]
tdb/spinlock.c [deleted file]
tdb/spinlock.h [deleted file]
tdb/tdb.c [deleted file]
tdb/tdb.h [deleted file]
tdb/tdbconfig.h.in [deleted file]
tdb/tdbspeed.c [deleted file]
tdb/tdbtool.c [deleted file]
tdb/tdbtorture.c [deleted file]
thunar/Makefile.am
thunar/thunar-file.c
thunar/thunar-file.h
thunar/thunar-metafile.c [deleted file]
thunar/thunar-metafile.h [deleted file]
thunarx/thunarx-file-info.h

index 51fb0b1..f8754f9 100644 (file)
@@ -93,12 +93,6 @@ po/*.mo
 po/POTFILES
 po/.intltool-merge-cache
 po/stamp-*
-tdb/tdbconfig.h
-tdb/.*.swp
-tdb/tdbspeed
-tdb/tdbtool
-tdb/tdbtorture
-tdb/*.tdb
 tests/*.loT
 tests/.*.swp
 tests/core.*
diff --git a/AUTHORS b/AUTHORS
index 34a0f53..6d1745a 100644 (file)
--- a/AUTHORS
+++ b/AUTHORS
@@ -3,13 +3,6 @@ Jannis Pohlmann <jannis@xfce.org>
 Jeffs Franks <jcfranks@xfce.org>
 Nick Schermer <nick@xfce.org>
 
-The tdb library, which is included with the Thunar distribution, was originally
-written as part of the Samba suite. My understanding is that the majority of
-the code was written by Andrew Trigell <tridge@linuxcare.com> with the help of
-Paul "Rusty" Russell <rusty@linuxcare.com>. Luke Kenneth Casson Leighton
-<luke@samba.org> also contributed a few patches. Sorted freelist merge code
-added by Jeremy Allison <jeremy@valinux.com>.
-
 The stock_folder-copy and stock_folder-move icons where taken from 
 gnome-icon-theme 2.18.0 whose authors are Lapo Calamandrei <calamandrei@gmail.com>,
 Rodney Dawes <dobey@novell.com>, Luca Ferretti <elle.uca@libero.it>,
diff --git a/FAQ b/FAQ
index bd59a48..be5d5dc 100644 (file)
--- a/FAQ
+++ b/FAQ
@@ -27,14 +27,7 @@ appropriate answers to these questions.
 3. Where does Thunar store the metadata associated with files?
 ==============================================================
 
-  Thunar associates various settings with files/folders, which we call metadata.
-  This metadata for all files is stored in tdb database file, which is called
-  the metafile. The database file is stored in
-  
-    $XDG_CACHE_HOME/Thunar/metafile.tdb
-
-  and can be examined using the tdbtool, which is part of the Thunar
-  distribution (located in the tdb/ subdirectory).
+  Thunar uses the metadata daemon provided by GVFS.
 
 
 4. Where does Thunar store its preferences?
index 88fc939..ece3b41 100644 (file)
@@ -21,7 +21,6 @@ SUBDIRS =                                                             \
        icons                                                           \
        pixmaps                                                         \
        po                                                              \
-       tdb                                                             \
        thunarx                                                         \
        thunar                                                          \
        docs                                                            \
index 619a231..5e4014e 100644 (file)
@@ -106,21 +106,6 @@ AC_ARG_WITH([helper-path-prefix],
 AC_SUBST([HELPER_PATH_PREFIX])
 
 dnl ***********************************************
-dnl *** Determine the u32 type required for tdb ***
-dnl ***********************************************
-AC_CHECK_SIZEOF([int])
-AC_CHECK_SIZEOF([long])
-AC_CHECK_SIZEOF([short])
-AC_MSG_CHECKING([for 32bit unsigned integer])
-case 4 in
-$ac_cv_sizeof_int)   TDB_U32_TYPE="unsigned int" ;;
-$ac_cv_sizeof_long)  TDB_U32_TYPE="unsigned long" ;;
-$ac_cv_sizeof_short) TDB_U32_TYPE="unsigned short" ;;
-esac
-AC_SUBST([TDB_U32_TYPE])
-AC_MSG_RESULT([$TDB_U32_TYPE])
-
-dnl ***********************************************
 dnl *** Work-around system-specific limitations ***
 dnl ***********************************************
 AC_SYS_LARGEFILE()
@@ -274,8 +259,6 @@ plugins/thunar-tpa/Makefile
 plugins/thunar-uca/Makefile
 plugins/thunar-wallpaper/Makefile
 po/Makefile.in
-tdb/Makefile
-tdb/tdbconfig.h
 thunar/Makefile
 thunarx/Makefile
 thunarx/thunarx-2.pc
index c7aee64..9d64bf4 100644 (file)
@@ -1,4 +1,3 @@
-tdb/spinlock.c
 thunarx/thunarx-file-info.c
 thunarx/thunarx-menu-provider.c
 thunarx/thunarx-preferences-provider.c
diff --git a/tdb/Makefile.am b/tdb/Makefile.am
deleted file mode 100644 (file)
index a515b15..0000000
+++ /dev/null
@@ -1,66 +0,0 @@
-# $Id$
-
-INCLUDES =                                                             \
-       -I$(top_srcdir)                                                 \
-       $(PLATFORM_CFLAGS)
-
-noinst_LTLIBRARIES =                                                   \
-       libtdb.la
-
-libtdb_la_SOURCES =                                                    \
-       spinlock.c                                                      \
-       spinlock.h                                                      \
-       tdb.c                                                           \
-       tdb.h                                                           \
-       tdbconfig.h
-
-noinst_PROGRAMS =                                                      \
-       tdbtool
-
-tdbtool_SOURCES =                                                      \
-       tdbtool.c
-
-tdbtool_DEPENDENCIES =                                                 \
-       libtdb.la
-
-tdbtool_LDADD =                                                                \
-       libtdb.la
-
-TESTS =                                                                        \
-       tdbspeed                                                        \
-       tdbtorture
-
-check_PROGRAMS =                                                       \
-       tdbspeed                                                        \
-       tdbtorture
-
-tdbspeed_SOURCES =                                                     \
-       tdbspeed.c
-
-tdbspeed_DEPENDENCIES =                                                        \
-       libtdb.la
-
-tdbspeed_LDADD =                                                       \
-       libtdb.la
-
-tdbtorture_CFLAGS =                                                    \
-       -DNLOOPS=1000                                                   \
-       -DNPROCS=10
-
-tdbtorture_SOURCES =                                                   \
-       tdbtorture.c
-
-tdbtorture_DEPENDENCIES =                                              \
-       libtdb.la
-
-tdbtorture_LDADD =                                                     \
-       libtdb.la
-
-CLEANFILES =                                                           \
-       test.tdb                                                        \
-       torture.tdb
-
-EXTRA_DIST =                                                           \
-       README
-
-# vi:set ts=8 sw=8 noet ai nocindent syntax=automake:
diff --git a/tdb/README b/tdb/README
deleted file mode 100644 (file)
index fac3eac..0000000
+++ /dev/null
@@ -1,167 +0,0 @@
-tdb - a trivial database system
-tridge@linuxcare.com December 1999
-==================================
-
-This is a simple database API. It was inspired by the realisation that
-in Samba we have several ad-hoc bits of code that essentially
-implement small databases for sharing structures between parts of
-Samba. As I was about to add another I realised that a generic
-database module was called for to replace all the ad-hoc bits.
-
-I based the interface on gdbm. I couldn't use gdbm as we need to be
-able to have multiple writers to the databases at one time.
-
-Compilation
------------
-
-add HAVE_MMAP=1 to use mmap instead of read/write
-add TDB_DEBUG=1 for verbose debug info
-add NOLOCK=1 to disable locking code
-
-Testing
--------
-
-Compile tdbtest.c and link with gdbm for testing. tdbtest will perform
-identical operations via tdb and gdbm then make sure the result is the
-same
-
-Also included is tdbtool, which allows simple database manipulation
-on the commandline.
-
-tdbtest and tdbtool are not built as part of Samba, but are included
-for completeness.
-
-Interface
----------
-
-The interface is very similar to gdbm except for the following:
-
-- different open interface. The tdb_open call is more similar to a
-  traditional open()
-- no tdbm_reorganise() function
-- no tdbm_sync() function. No operations are cached in the library anyway
-- added a tdb_traverse() function for traversing the whole database
-
-A general rule for using tdb is that the caller frees any returned
-TDB_DATA structures. Just call free(p.dptr) to free a TDB_DATA
-return value called p. This is the same as gdbm.
-
-here is a full list of tdb functions with brief descriptions.
-
-
-----------------------------------------------------------------------
-TDB_CONTEXT *tdb_open(char *name, int hash_size, int tdb_flags,
-                     int open_flags, mode_t mode)
-
-   open the database, creating it if necessary 
-
-   The open_flags and mode are passed straight to the open call on the database
-   file. A flags value of O_WRONLY is invalid
-
-   The hash size is advisory, use zero for a default value. 
-
-   return is NULL on error
-
-   possible tdb_flags are:
-    TDB_CLEAR_IF_FIRST - clear database if we are the only one with it open
-    TDB_INTERNAL - don't use a file, instaed store the data in
-                   memory. The filename is ignored in this case.
-    TDB_NOLOCK - don't do any locking
-    TDB_NOMMAP - don't use mmap
-
-----------------------------------------------------------------------
-char *tdb_error(TDB_CONTEXT *tdb);
-
-     return a error string for the last tdb error
-
-----------------------------------------------------------------------
-int tdb_close(TDB_CONTEXT *tdb);
-
-   close a database
-
-----------------------------------------------------------------------
-int tdb_update(TDB_CONTEXT *tdb, TDB_DATA key, TDB_DATA dbuf);
-
-   update an entry in place - this only works if the new data size
-   is <= the old data size and the key exists.
-   on failure return -1
-
-----------------------------------------------------------------------
-TDB_DATA tdb_fetch(TDB_CONTEXT *tdb, TDB_DATA key);
-
-   fetch an entry in the database given a key 
-   if the return value has a null dptr then a error occurred
-
-   caller must free the resulting data
-
-----------------------------------------------------------------------
-int tdb_exists(TDB_CONTEXT *tdb, TDB_DATA key);
-
-   check if an entry in the database exists 
-
-   note that 1 is returned if the key is found and 0 is returned if not found
-   this doesn't match the conventions in the rest of this module, but is
-   compatible with gdbm
-
-----------------------------------------------------------------------
-int tdb_traverse(TDB_CONTEXT *tdb, int (*fn)(TDB_CONTEXT *tdb,
-                 TDB_DATA key, TDB_DATA dbuf, void *state), void *state);
-
-   traverse the entire database - calling fn(tdb, key, data, state) on each 
-   element.
-
-   return -1 on error or the record count traversed
-
-   if fn is NULL then it is not called
-
-   a non-zero return value from fn() indicates that the traversal should stop
-
-----------------------------------------------------------------------
-TDB_DATA tdb_firstkey(TDB_CONTEXT *tdb);
-
-   find the first entry in the database and return its key
-
-   the caller must free the returned data
-
-----------------------------------------------------------------------
-TDB_DATA tdb_nextkey(TDB_CONTEXT *tdb, TDB_DATA key);
-
-   find the next entry in the database, returning its key
-
-   the caller must free the returned data
-
-----------------------------------------------------------------------
-int tdb_delete(TDB_CONTEXT *tdb, TDB_DATA key);
-
-   delete an entry in the database given a key
-
-----------------------------------------------------------------------
-int tdb_store(TDB_CONTEXT *tdb, TDB_DATA key, TDB_DATA dbuf, int flag);
-
-   store an element in the database, replacing any existing element
-   with the same key 
-
-   If flag==TDB_INSERT then don't overwrite an existing entry
-   If flag==TDB_MODIFY then don't create a new entry
-
-   return 0 on success, -1 on failure
-
-----------------------------------------------------------------------
-int tdb_writelock(TDB_CONTEXT *tdb);
-
-   lock the database. If we already have it locked then don't do anything
-
-----------------------------------------------------------------------
-int tdb_writeunlock(TDB_CONTEXT *tdb);
-   unlock the database
-
-----------------------------------------------------------------------
-int tdb_lockchain(TDB_CONTEXT *tdb, TDB_DATA key);
-
-   lock one hash chain. This is meant to be used to reduce locking
-   contention - it cannot guarantee how many records will be locked
-
-----------------------------------------------------------------------
-int tdb_unlockchain(TDB_CONTEXT *tdb, TDB_DATA key);
-
-   unlock one hash chain
diff --git a/tdb/spinlock.c b/tdb/spinlock.c
deleted file mode 100644 (file)
index 9b726e7..0000000
+++ /dev/null
@@ -1,494 +0,0 @@
-/* $Id$ */
-/*-
- * Copyright (c) 2001 Anton Blanchard <anton@samba.org>
- * Copyright (c) 2005 Benedikt Meurer <benny@xfce.org>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library 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
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public
- * License along with this library; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
- *
- * This file was originally part of the tdb library, which in turn is
- * part of the Samba suite, a Unix SMB/CIFS implementation.
- */
-
-#if HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#ifdef HAVE_SYS_TYPES_H
-#include <sys/types.h>
-#endif
-#ifdef HAVE_SYS_STAT_H
-#include <sys/stat.h>
-#endif
-
-#ifdef HAVE_ERRNO_H
-#include <errno.h>
-#endif
-#ifdef HAVE_FCNTL_H
-#include <fcntl.h>
-#endif
-#ifdef HAVE_SCHED_H
-#include <sched.h>
-#endif
-#include <stdio.h>
-#ifdef HAVE_STDLIB_H
-#include <stdlib.h>
-#endif
-#ifdef HAVE_STRING_H
-#include <string.h>
-#endif
-#ifdef HAVE_TIME_H
-#include <time.h>
-#endif
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-
-#include <tdb/spinlock.h>
-
-#ifdef USE_SPINLOCKS
-
-/*
- * ARCH SPECIFIC
- */
-
-#if defined(SPARC_SPINLOCKS)
-
-static inline int __spin_trylock(spinlock_t *lock)
-{
-       unsigned int result;
-
-       asm volatile("ldstub    [%1], %0"
-               : "=r" (result)
-               : "r" (lock)
-               : "memory");
-
-       return (result == 0) ? 0 : EBUSY;
-}
-
-static inline void __spin_unlock(spinlock_t *lock)
-{
-       asm volatile("":::"memory");
-       *lock = 0;
-}
-
-static inline void __spin_lock_init(spinlock_t *lock)
-{
-       *lock = 0;
-}
-
-static inline int __spin_is_locked(spinlock_t *lock)
-{
-       return (*lock != 0);
-}
-
-#elif defined(POWERPC_SPINLOCKS) 
-
-static inline int __spin_trylock(spinlock_t *lock)
-{
-       unsigned int result;
-
-       __asm__ __volatile__(
-"1:    lwarx           %0,0,%1\n\
-       cmpwi           0,%0,0\n\
-       li              %0,0\n\
-       bne-            2f\n\
-       li              %0,1\n\
-       stwcx.          %0,0,%1\n\
-       bne-            1b\n\
-       isync\n\
-2:"    : "=&r"(result)
-       : "r"(lock)
-       : "cr0", "memory");
-
-       return (result == 1) ? 0 : EBUSY;
-}
-
-static inline void __spin_unlock(spinlock_t *lock)
-{
-       asm volatile("eieio":::"memory");
-       *lock = 0;
-}
-
-static inline void __spin_lock_init(spinlock_t *lock)
-{
-       *lock = 0;
-}
-
-static inline int __spin_is_locked(spinlock_t *lock)
-{
-       return (*lock != 0);
-}
-
-#elif defined(INTEL_SPINLOCKS) 
-
-static inline int __spin_trylock(spinlock_t *lock)
-{
-       int oldval;
-
-       asm volatile("xchgl %0,%1"
-               : "=r" (oldval), "=m" (*lock)
-               : "0" (0)
-               : "memory");
-
-       return oldval > 0 ? 0 : EBUSY;
-}
-
-static inline void __spin_unlock(spinlock_t *lock)
-{
-       asm volatile("":::"memory");
-       *lock = 1;
-}
-
-static inline void __spin_lock_init(spinlock_t *lock)
-{
-       *lock = 1;
-}
-
-static inline int __spin_is_locked(spinlock_t *lock)
-{
-       return (*lock != 1);
-}
-
-#elif defined(MIPS_SPINLOCKS) && defined(sgi) && (_COMPILER_VERSION >= 730)
-
-/* Implement spinlocks on IRIX using the MIPSPro atomic fetch operations. See
- * sync(3) for the details of the intrinsic operations.
- *
- * "sgi" and "_COMPILER_VERSION" are always defined by MIPSPro.
- */
-
-#ifdef STANDALONE
-
-/* MIPSPro 7.3 has "__inline" as an extension, but not "inline. */
-#define inline __inline
-
-#endif /* STANDALONE */
-
-/* Returns 0 if the lock is acquired, EBUSY otherwise. */
-static inline int __spin_trylock(spinlock_t *lock)
-{
-        unsigned int val;
-        val = __lock_test_and_set(lock, 1);
-        return val == 0 ? 0 : EBUSY;
-}
-
-static inline void __spin_unlock(spinlock_t *lock)
-{
-        __lock_release(lock);
-}
-
-static inline void __spin_lock_init(spinlock_t *lock)
-{
-        __lock_release(lock);
-}
-
-/* Returns 1 if the lock is held, 0 otherwise. */
-static inline int __spin_is_locked(spinlock_t *lock)
-{
-        unsigned int val;
-        val = __add_and_fetch(lock, 0);
-       return val;
-}
-
-#elif defined(MIPS_SPINLOCKS) 
-
-static inline unsigned int load_linked(unsigned long addr)
-{
-       unsigned int res;
-
-       __asm__ __volatile__("ll\t%0,(%1)"
-               : "=r" (res)
-               : "r" (addr));
-
-       return res;
-}
-
-static inline unsigned int store_conditional(unsigned long addr, unsigned int value)
-{
-       unsigned int res;
-
-       __asm__ __volatile__("sc\t%0,(%2)"
-               : "=r" (res)
-               : "0" (value), "r" (addr));
-       return res;
-}
-
-static inline int __spin_trylock(spinlock_t *lock)
-{
-       unsigned int mw;
-
-       do {
-               mw = load_linked(lock);
-               if (mw) 
-                       return EBUSY;
-       } while (!store_conditional(lock, 1));
-
-       asm volatile("":::"memory");
-
-       return 0;
-}
-
-static inline void __spin_unlock(spinlock_t *lock)
-{
-       asm volatile("":::"memory");
-       *lock = 0;
-}
-
-static inline void __spin_lock_init(spinlock_t *lock)
-{
-       *lock = 0;
-}
-
-static inline int __spin_is_locked(spinlock_t *lock)
-{
-       return (*lock != 0);
-}
-
-#else
-#error Need to implement spinlock code in spinlock.c
-#endif
-
-/*
- * OS SPECIFIC
- */
-
-static void yield_cpu(void)
-{
-       struct timespec tm;
-
-#ifdef HAVE_SCHED_YIELD
-       sched_yield();
-#else
-       /* Linux will busy loop for delays < 2ms on real time tasks */
-       tm.tv_sec = 0;
-       tm.tv_nsec = 2000000L + 1;
-       nanosleep(&tm, NULL);
-#endif
-}
-
-static int this_is_smp(void)
-{
-#if defined(HAVE_SYSCONF) && defined(SYSCONF_SC_NPROC_ONLN)
-        return (sysconf(_SC_NPROC_ONLN) > 1) ? 1 : 0;
-#else
-       return 0;
-#endif
-}
-
-/*
- * GENERIC
- */
-
-static int smp_machine = 0;
-
-static inline void __spin_lock(spinlock_t *lock)
-{
-       int ntries = 0;
-
-       while(__spin_trylock(lock)) {
-               while(__spin_is_locked(lock)) {
-                       if (smp_machine && ntries++ < MAX_BUSY_LOOPS)
-                               continue;
-                       yield_cpu();
-               }
-       }
-}
-
-static void __read_lock(tdb_rwlock_t *rwlock)
-{
-       int ntries = 0;
-
-       while(1) {
-               __spin_lock(&rwlock->lock);
-
-               if (!(rwlock->count & RWLOCK_BIAS)) {
-                       rwlock->count++;
-                       __spin_unlock(&rwlock->lock);
-                       return;
-               }
-       
-               __spin_unlock(&rwlock->lock);
-
-               while(rwlock->count & RWLOCK_BIAS) {
-                       if (smp_machine && ntries++ < MAX_BUSY_LOOPS)
-                               continue;
-                       yield_cpu();
-               }
-       }
-}
-
-static void __write_lock(tdb_rwlock_t *rwlock)
-{
-       int ntries = 0;
-
-       while(1) {
-               __spin_lock(&rwlock->lock);
-
-               if (rwlock->count == 0) {
-                       rwlock->count |= RWLOCK_BIAS;
-                       __spin_unlock(&rwlock->lock);
-                       return;
-               }
-
-               __spin_unlock(&rwlock->lock);
-
-               while(rwlock->count != 0) {
-                       if (smp_machine && ntries++ < MAX_BUSY_LOOPS)
-                               continue;
-                       yield_cpu();
-               }
-       }
-}
-
-static void __write_unlock(tdb_rwlock_t *rwlock)
-{
-       __spin_lock(&rwlock->lock);
-
-#ifdef DEBUG
-       if (!(rwlock->count & RWLOCK_BIAS))
-               fprintf(stderr, "bug: write_unlock\n");
-#endif
-
-       rwlock->count &= ~RWLOCK_BIAS;
-       __spin_unlock(&rwlock->lock);
-}
-
-static void __read_unlock(tdb_rwlock_t *rwlock)
-{
-       __spin_lock(&rwlock->lock);
-
-#ifdef DEBUG
-       if (!rwlock->count)
-               fprintf(stderr, "bug: read_unlock\n");
-
-       if (rwlock->count & RWLOCK_BIAS)
-               fprintf(stderr, "bug: read_unlock\n");
-#endif
-
-       rwlock->count--;
-       __spin_unlock(&rwlock->lock);
-}
-
-/* TDB SPECIFIC */
-
-/* lock a list in the database. list -1 is the alloc list */
-int tdb_spinlock(TDB_CONTEXT *tdb, int list, int rw_type)
-{
-       tdb_rwlock_t *rwlocks;
-
-       if (!tdb->map_ptr) return -1;
-       rwlocks = (tdb_rwlock_t *)((char *)tdb->map_ptr + tdb->header.rwlocks);
-
-       switch(rw_type) {
-       case F_RDLCK:
-               __read_lock(&rwlocks[list+1]);
-               break;
-
-       case F_WRLCK:
-               __write_lock(&rwlocks[list+1]);
-               break;
-
-       default:
-               return TDB_ERRCODE(TDB_ERR_LOCK, -1);
-       }
-       return 0;
-}
-
-/* unlock the database. */
-int tdb_spinunlock(TDB_CONTEXT *tdb, int list, int rw_type)
-{
-       tdb_rwlock_t *rwlocks;
-
-       if (!tdb->map_ptr) return -1;
-       rwlocks = (tdb_rwlock_t *)((char *)tdb->map_ptr + tdb->header.rwlocks);
-
-       switch(rw_type) {
-       case F_RDLCK:
-               __read_unlock(&rwlocks[list+1]);
-               break;
-
-       case F_WRLCK:
-               __write_unlock(&rwlocks[list+1]);
-               break;
-
-       default:
-               return TDB_ERRCODE(TDB_ERR_LOCK, -1);
-       }
-
-       return 0;
-}
-
-int tdb_create_rwlocks(int fd, unsigned int hash_size)
-{
-       unsigned size, i;
-       tdb_rwlock_t *rwlocks;
-
-       size = TDB_SPINLOCK_SIZE(hash_size);
-       rwlocks = malloc(size);
-       if (!rwlocks)
-               return -1;
-
-       for(i = 0; i < hash_size+1; i++) {
-               __spin_lock_init(&rwlocks[i].lock);
-               rwlocks[i].count = 0;
-       }
-
-       /* Write it out (appending to end) */
-       if (write(fd, rwlocks, size) != size) {
-               free(rwlocks);
-               return -1;
-       }
-       smp_machine = this_is_smp();
-       free(rwlocks);
-       return 0;
-}
-
-int tdb_clear_spinlocks(TDB_CONTEXT *tdb)
-{
-       tdb_rwlock_t *rwlocks;
-       unsigned i;
-
-       if (tdb->header.rwlocks == 0) return 0;
-       if (!tdb->map_ptr) return -1;
-
-       /* We're mmapped here */
-       rwlocks = (tdb_rwlock_t *)((char *)tdb->map_ptr + tdb->header.rwlocks);
-       for(i = 0; i < tdb->header.hash_size+1; i++) {
-               __spin_lock_init(&rwlocks[i].lock);
-               rwlocks[i].count = 0;
-       }
-       return 0;
-}
-#else
-int tdb_create_rwlocks(int fd, unsigned int hash_size) { return 0; }
-int tdb_spinlock(TDB_CONTEXT *tdb, int list, int rw_type) { return -1; }
-int tdb_spinunlock(TDB_CONTEXT *tdb, int list, int rw_type) { return -1; }
-
-/* Non-spinlock version: remove spinlock pointer */
-int tdb_clear_spinlocks(TDB_CONTEXT *tdb)
-{
-       tdb_off off = (tdb_off)((char *)&tdb->header.rwlocks
-                               - (char *)&tdb->header);
-
-       tdb->header.rwlocks = 0;
-       if (lseek(tdb->fd, off, SEEK_SET) != off
-           || write(tdb->fd, (void *)&tdb->header.rwlocks,
-                    sizeof(tdb->header.rwlocks)) 
-           != sizeof(tdb->header.rwlocks))
-               return -1;
-       return 0;
-}
-#endif
diff --git a/tdb/spinlock.h b/tdb/spinlock.h
deleted file mode 100644 (file)
index f492df1..0000000
+++ /dev/null
@@ -1,77 +0,0 @@
-/* $Id$ */
-/*-
- * Copyright (c) 2001 Anton Blanchard <anton@samba.org>
- * Copyright (c) 2005 Benedikt Meurer <benny@xfce.org>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library 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
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public
- * License along with this library; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
- *
- * This file was originally part of the tdb library, which in turn is
- * part of the Samba suite, a Unix SMB/CIFS implementation.
- */
-
-#ifndef __SPINLOCK_H__
-#define __SPINLOCK_H__
-
-#include <tdb/tdb.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifdef USE_SPINLOCKS
-
-#define RWLOCK_BIAS 0x1000UL
-
-/* OS SPECIFIC */
-#define MAX_BUSY_LOOPS 1000
-
-/* ARCH SPECIFIC */
-/* We should make sure these are padded to a cache line */
-#if defined(SPARC_SPINLOCKS)
-typedef volatile char spinlock_t;
-#elif defined(POWERPC_SPINLOCKS)
-typedef volatile unsigned long spinlock_t;
-#elif defined(INTEL_SPINLOCKS)
-typedef volatile int spinlock_t;
-#elif defined(MIPS_SPINLOCKS)
-typedef volatile unsigned long spinlock_t;
-#else
-#error Need to implement spinlock code in spinlock.h
-#endif
-
-typedef struct {
-       spinlock_t lock;
-       volatile int count;
-} tdb_rwlock_t;
-
-#define TDB_SPINLOCK_SIZE(hash_size) (((hash_size) + 1) * sizeof(tdb_rwlock_t))
-
-#else /* !USE_SPINLOCKS */
-
-#define TDB_SPINLOCK_SIZE(hash_size) 0
-
-#endif /* !USE_SPINLOCKS */
-
-int tdb_spinlock(TDB_CONTEXT *tdb, int list, int rw_type);
-int tdb_spinunlock(TDB_CONTEXT *tdb, int list, int rw_type);
-int tdb_create_rwlocks(int fd, unsigned int hash_size);
-int tdb_clear_spinlocks(TDB_CONTEXT *tdb);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* !__SPINLOCK_H__ */
diff --git a/tdb/tdb.c b/tdb/tdb.c
deleted file mode 100644 (file)
index 898316a..0000000
--- a/tdb/tdb.c
+++ /dev/null
@@ -1,2099 +0,0 @@
-/* $Id$ */
-/*-
- * Copyright (c) 1999-2004 Andrew Tridgell <tridge@linuxcare.com>
- * Copyright (c) 2000      Paul `Rusty' Russel <rusty@linuxcare.com>
- * Copyright (c) 2000-2003 Jeremy Allison <jeremy@valinux.com>
- * Copyright (c) 2005      Benedikt Meurer <benny@xfce.org>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library 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
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public
- * License along with this library; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
- *
- * This file was originally part of the tdb library, which in turn is
- * part of the Samba suite, a Unix SMB/CIFS implementation.
- */
-
-/* NOTE: If you use tdbs under valgrind, and in particular if you run
- * tdbtorture, you may get spurious "uninitialized value" warnings.  I
- * think this is because valgrind doesn't understand that the mmap'd
- * area may be written to by other processes.  Memory can, from the
- * point of view of the grinded process, spontaneously become
- * initialized.
- *
- * I can think of a few solutions.  [mbp 20030311]
- *
- * 1 - Write suppressions for Valgrind so that it doesn't complain
- * about this.  Probably the most reasonable but people need to
- * remember to use them.
- *
- * 2 - Use IO not mmap when running under valgrind.  Not so nice.
- *
- * 3 - Use the special valgrind macros to mark memory as valid at the
- * right time.  Probably too hard -- the process just doesn't know.
- */ 
-
-#if HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#ifdef HAVE_SYS_TYPES_H
-#include <sys/types.h>
-#endif
-#ifdef HAVE_SYS_MMAN_H
-#include <sys/mman.h>
-#endif
-#ifdef HAVE_SYS_STAT_H
-#include <sys/stat.h>
-#endif
-#ifdef HAVE_SYS_UI_H
-#include <sys/uio.h>
-#endif
-
-#ifdef HAVE_ERRNO_H
-#include <errno.h>
-#endif
-#ifdef HAVE_FCNTL_H
-#include <fcntl.h>
-#endif
-#ifdef HAVE_MEMORY_H
-#include <memory.h>
-#endif
-#ifdef HAVE_STDLIB_H
-#include <stdlib.h>
-#endif
-#include <stdio.h>
-#ifdef HAVE_STRING_H
-#include <string.h>
-#endif
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-
-#include <tdb/spinlock.h>
-#include <tdb/tdb.h>
-
-#define TDB_MAGIC_FOOD "TDB file\n"
-#define TDB_VERSION (0x26011967 + 6)
-#define TDB_MAGIC (0x26011999U)
-#define TDB_FREE_MAGIC (~TDB_MAGIC)
-#define TDB_DEAD_MAGIC (0xFEE1DEAD)
-#define TDB_ALIGNMENT 4
-#define MIN_REC_SIZE (2*sizeof(struct list_struct) + TDB_ALIGNMENT)
-#define DEFAULT_HASH_SIZE 131
-#define TDB_PAGE_SIZE 0x2000
-#define FREELIST_TOP (sizeof(struct tdb_header))
-#define TDB_ALIGN(x,a) (((x) + (a)-1) & ~((a)-1))
-#define TDB_BYTEREV(x) (((((x)&0xff)<<24)|((x)&0xFF00)<<8)|(((x)>>8)&0xFF00)|((x)>>24))
-#define TDB_DEAD(r) ((r)->magic == TDB_DEAD_MAGIC)
-#define TDB_BAD_MAGIC(r) ((r)->magic != TDB_MAGIC && !TDB_DEAD(r))
-#define TDB_HASH_TOP(hash) (FREELIST_TOP + (BUCKET(hash)+1)*sizeof(tdb_off))
-#define TDB_DATA_START(hash_size) (TDB_HASH_TOP(hash_size-1) + TDB_SPINLOCK_SIZE(hash_size))
-
-
-/* NB assumes there is a local variable called "tdb" that is the
- * current context, also takes doubly-parenthesized print-style
- * argument. */
-#define TDB_LOG(x) (tdb->log_fn?((tdb->log_fn x),0) : 0)
-
-/* lock offsets */
-#define GLOBAL_LOCK 0
-#define ACTIVE_LOCK 4
-
-#ifndef MAP_FILE
-#define MAP_FILE 0
-#endif
-
-#ifndef MAP_FAILED
-#define MAP_FAILED ((void *)-1)
-#endif
-
-/* free memory if the pointer is valid and zero the pointer */
-#ifndef SAFE_FREE
-#define SAFE_FREE(x) do { if ((x) != NULL) {free((x)); (x)=NULL;} } while(0)
-#endif
-
-#define BUCKET(hash) ((hash) % tdb->header.hash_size)
-TDB_DATA tdb_null;
-
-/* all contexts, to ensure no double-opens (fcntl locks don't nest!) */
-static TDB_CONTEXT *tdbs = NULL;
-
-static int tdb_munmap(TDB_CONTEXT *tdb)
-{
-       if (tdb->flags & TDB_INTERNAL)
-               return 0;
-
-#ifdef HAVE_MMAP
-       if (tdb->map_ptr) {
-               int ret = munmap(tdb->map_ptr, tdb->map_size);
-               if (ret != 0)
-                       return ret;
-       }
-#endif
-       tdb->map_ptr = NULL;
-       return 0;
-}
-
-static void tdb_mmap(TDB_CONTEXT *tdb)
-{
-       if (tdb->flags & TDB_INTERNAL)
-               return;
-
-#ifdef HAVE_MMAP
-       if (!(tdb->flags & TDB_NOMMAP)) {
-               tdb->map_ptr = mmap(NULL, tdb->map_size, 
-                                   PROT_READ|(tdb->read_only? 0:PROT_WRITE), 
-                                   MAP_SHARED|MAP_FILE, tdb->fd, 0);
-
-               /*
-                * NB. When mmap fails it returns MAP_FAILED *NOT* NULL !!!!
-                */
-
-               if (tdb->map_ptr == MAP_FAILED) {
-                       tdb->map_ptr = NULL;
-                       TDB_LOG((tdb, 2, "tdb_mmap failed for size %d (%s)\n", 
-                                tdb->map_size, strerror(errno)));
-               }
-       } else {
-               tdb->map_ptr = NULL;
-       }
-#else
-       tdb->map_ptr = NULL;
-#endif
-}
-
-/* Endian conversion: we only ever deal with 4 byte quantities */
-static void *convert(void *buf, u32 size)
-{
-       u32 i, *p = buf;
-       for (i = 0; i < size / 4; i++)
-               p[i] = TDB_BYTEREV(p[i]);
-       return buf;
-}
-#define DOCONV() (tdb->flags & TDB_CONVERT)
-#define CONVERT(x) (DOCONV() ? convert(&x, sizeof(x)) : &x)
-
-/* the body of the database is made of one list_struct for the free space
-   plus a separate data list for each hash value */
-struct list_struct {
-       tdb_off next; /* offset of the next record in the list */
-       tdb_len rec_len; /* total byte length of record */
-       tdb_len key_len; /* byte length of key */
-       tdb_len data_len; /* byte length of data */
-       u32 full_hash; /* the full 32 bit hash of the key */
-       u32 magic;   /* try to catch errors */
-       /* the following union is implied:
-               union {
-                       char record[rec_len];
-                       struct {
-                               char key[key_len];
-                               char data[data_len];
-                       }
-                       u32 totalsize; (tailer)
-               }
-       */
-};
-
-/***************************************************************
- Allow a caller to set a "alarm" flag that tdb can check to abort
- a blocking lock on SIGALRM.
-***************************************************************/
-
-static sig_atomic_t *palarm_fired;
-
-void tdb_set_lock_alarm(sig_atomic_t *palarm)
-{
-       palarm_fired = palarm;
-}
-
-/* a byte range locking function - return 0 on success
-   this functions locks/unlocks 1 byte at the specified offset.
-
-   On error, errno is also set so that errors are passed back properly
-   through tdb_open(). */
-static int tdb_brlock(TDB_CONTEXT *tdb, tdb_off offset, 
-                     int rw_type, int lck_type, int probe)
-{
-       struct flock fl;
-       int ret;
-
-       if (tdb->flags & TDB_NOLOCK)
-               return 0;
-       if ((rw_type == F_WRLCK) && (tdb->read_only)) {
-               errno = EACCES;
-               return -1;
-       }
-
-       fl.l_type = rw_type;
-       fl.l_whence = SEEK_SET;
-       fl.l_start = offset;
-       fl.l_len = 1;
-       fl.l_pid = 0;
-
-       do {
-               ret = fcntl(tdb->fd,lck_type,&fl);
-               if (ret == -1 && errno == EINTR && palarm_fired && *palarm_fired)
-                       break;
-       } while (ret == -1 && errno == EINTR);
-
-       if (ret == -1) {
-               if (!probe && lck_type != F_SETLK) {
-                       /* Ensure error code is set for log fun to examine. */
-                       if (errno == EINTR && palarm_fired && *palarm_fired)
-                               tdb->ecode = TDB_ERR_LOCK_TIMEOUT;
-                       else
-                               tdb->ecode = TDB_ERR_LOCK;
-                       TDB_LOG((tdb, 5,"tdb_brlock failed (fd=%d) at offset %d rw_type=%d lck_type=%d\n", 
-                                tdb->fd, offset, rw_type, lck_type));
-               }
-               /* Was it an alarm timeout ? */
-               if (errno == EINTR && palarm_fired && *palarm_fired) {
-                       TDB_LOG((tdb, 5, "tdb_brlock timed out (fd=%d) at offset %d rw_type=%d lck_type=%d\n", 
-                                tdb->fd, offset, rw_type, lck_type));
-                       return TDB_ERRCODE(TDB_ERR_LOCK_TIMEOUT, -1);
-               }
-               /* Otherwise - generic lock error. errno set by fcntl.
-                * EAGAIN is an expected return from non-blocking
-                * locks. */
-               if (errno != EAGAIN) {
-                       TDB_LOG((tdb, 5, "tdb_brlock failed (fd=%d) at offset %d rw_type=%d lck_type=%d: %s\n", 
-                                tdb->fd, offset, rw_type, lck_type, 
-                                strerror(errno)));
-               }
-               return TDB_ERRCODE(TDB_ERR_LOCK, -1);
-       }
-       return 0;
-}
-
-/* lock a list in the database. list -1 is the alloc list */
-static int tdb_lock(TDB_CONTEXT *tdb, int list, int ltype)
-{
-       if (list < -1 || list >= (int)tdb->header.hash_size) {
-               TDB_LOG((tdb, 0,"tdb_lock: invalid list %d for ltype=%d\n", 
-                          list, ltype));
-               return -1;
-       }
-       if (tdb->flags & TDB_NOLOCK)
-               return 0;
-
-       /* Since fcntl locks don't nest, we do a lock for the first one,
-          and simply bump the count for future ones */
-       if (tdb->locked[list+1].count == 0) {
-               if (!tdb->read_only && tdb->header.rwlocks) {
-                       if (tdb_spinlock(tdb, list, ltype)) {
-                               TDB_LOG((tdb, 0, "tdb_lock spinlock failed on list %d ltype=%d\n", 
-                                          list, ltype));
-                               return -1;
-                       }
-               } else if (tdb_brlock(tdb,FREELIST_TOP+4*list,ltype,F_SETLKW, 0)) {
-                       TDB_LOG((tdb, 0,"tdb_lock failed on list %d ltype=%d (%s)\n", 
-                                          list, ltype, strerror(errno)));
-                       return -1;
-               }
-               tdb->locked[list+1].ltype = ltype;
-       }
-       tdb->locked[list+1].count++;
-       return 0;
-}
-
-/* unlock the database: returns void because it's too late for errors. */
-       /* changed to return int it may be interesting to know there
-          has been an error  --simo */
-static int tdb_unlock(TDB_CONTEXT *tdb, int list, int ltype)
-{
-       int ret = -1;
-
-       if (tdb->flags & TDB_NOLOCK)
-               return 0;
-
-       /* Sanity checks */
-       if (list < -1 || list >= (int)tdb->header.hash_size) {
-               TDB_LOG((tdb, 0, "tdb_unlock: list %d invalid (%d)\n", list, tdb->header.hash_size));
-               return ret;
-       }
-
-       if (tdb->locked[list+1].count==0) {
-               TDB_LOG((tdb, 0, "tdb_unlock: count is 0\n"));
-               return ret;
-       }
-
-       if (tdb->locked[list+1].count == 1) {
-               /* Down to last nested lock: unlock underneath */
-               if (!tdb->read_only && tdb->header.rwlocks) {
-                       ret = tdb_spinunlock(tdb, list, ltype);
-               } else {
-                       ret = tdb_brlock(tdb, FREELIST_TOP+4*list, F_UNLCK, F_SETLKW, 0);
-               }
-       } else {
-               ret = 0;
-       }
-       tdb->locked[list+1].count--;
-
-       if (ret)
-               TDB_LOG((tdb, 0,"tdb_unlock: An error occurred unlocking!\n")); 
-       return ret;
-}
-
-/* check for an out of bounds access - if it is out of bounds then
-   see if the database has been expanded by someone else and expand
-   if necessary 
-   note that "len" is the minimum length needed for the db
-*/
-static int tdb_oob(TDB_CONTEXT *tdb, tdb_off len, int probe)
-{
-       struct stat st;
-       if (len <= tdb->map_size)
-               return 0;
-       if (tdb->flags & TDB_INTERNAL) {
-               if (!probe) {
-                       /* Ensure ecode is set for log fn. */
-                       tdb->ecode = TDB_ERR_IO;
-                       TDB_LOG((tdb, 0,"tdb_oob len %d beyond internal malloc size %d\n",
-                                (int)len, (int)tdb->map_size));
-               }
-               return TDB_ERRCODE(TDB_ERR_IO, -1);
-       }
-
-       if (fstat(tdb->fd, &st) == -1)
-               return TDB_ERRCODE(TDB_ERR_IO, -1);
-
-       if (st.st_size < (off_t)len) {
-               if (!probe) {
-                       /* Ensure ecode is set for log fn. */
-                       tdb->ecode = TDB_ERR_IO;
-                       TDB_LOG((tdb, 0,"tdb_oob len %d beyond eof at %d\n",
-                                (int)len, (int)st.st_size));
-               }
-               return TDB_ERRCODE(TDB_ERR_IO, -1);
-       }
-
-       /* Unmap, update size, remap */
-       if (tdb_munmap(tdb) == -1)
-               return TDB_ERRCODE(TDB_ERR_IO, -1);
-       tdb->map_size = st.st_size;
-       tdb_mmap(tdb);
-       return 0;
-}
-
-/* write a lump of data at a specified offset */
-static int tdb_write(TDB_CONTEXT *tdb, tdb_off off, void *buf, tdb_len len)
-{
-       if (tdb_oob(tdb, off + len, 0) != 0)
-               return -1;
-
-       if (tdb->map_ptr)
-               memcpy(off + (char *)tdb->map_ptr, buf, len);
-#ifdef HAVE_PWRITE
-       else if (pwrite(tdb->fd, buf, len, off) != (ssize_t)len) {
-#else
-       else if (lseek(tdb->fd, off, SEEK_SET) != off
-                || write(tdb->fd, buf, len) != (ssize_t)len) {
-#endif
-               /* Ensure ecode is set for log fn. */
-               tdb->ecode = TDB_ERR_IO;
-               TDB_LOG((tdb, 0,"tdb_write failed at %d len=%d (%s)\n",
-                          off, len, strerror(errno)));
-               return TDB_ERRCODE(TDB_ERR_IO, -1);
-       }
-       return 0;
-}
-
-/* read a lump of data at a specified offset, maybe convert */
-static int tdb_read(TDB_CONTEXT *tdb,tdb_off off,void *buf,tdb_len len,int cv)
-{
-       if (tdb_oob(tdb, off + len, 0) != 0)
-               return -1;
-
-       if (tdb->map_ptr)
-               memcpy(buf, off + (char *)tdb->map_ptr, len);
-#ifdef HAVE_PREAD
-       else if (pread(tdb->fd, buf, len, off) != (ssize_t)len) {
-#else
-       else if (lseek(tdb->fd, off, SEEK_SET) != off
-                || read(tdb->fd, buf, len) != (ssize_t)len) {
-#endif
-               /* Ensure ecode is set for log fn. */
-               tdb->ecode = TDB_ERR_IO;
-               TDB_LOG((tdb, 0,"tdb_read failed at %d len=%d (%s)\n",
-                          off, len, strerror(errno)));
-               return TDB_ERRCODE(TDB_ERR_IO, -1);
-       }
-       if (cv)
-               convert(buf, len);
-       return 0;
-}
-
-/* read a lump of data, allocating the space for it */
-static char *tdb_alloc_read(TDB_CONTEXT *tdb, tdb_off offset, tdb_len len)
-{
-       char *buf;
-
-       if (!(buf = malloc(len))) {
-               /* Ensure ecode is set for log fn. */
-               tdb->ecode = TDB_ERR_OOM;
-               TDB_LOG((tdb, 0,"tdb_alloc_read malloc failed len=%d (%s)\n",
-                          len, strerror(errno)));
-               return TDB_ERRCODE(TDB_ERR_OOM, buf);
-       }
-       if (tdb_read(tdb, offset, buf, len, 0) == -1) {
-               SAFE_FREE(buf);
-               return NULL;
-       }
-       return buf;
-}
-
-/* read/write a tdb_off */
-static int ofs_read(TDB_CONTEXT *tdb, tdb_off offset, tdb_off *d)
-{
-       return tdb_read(tdb, offset, (char*)d, sizeof(*d), DOCONV());
-}
-static int ofs_write(TDB_CONTEXT *tdb, tdb_off offset, tdb_off *d)
-{
-       tdb_off off = *d;
-       return tdb_write(tdb, offset, CONVERT(off), sizeof(*d));
-}
-
-/* read/write a record */
-static int rec_read(TDB_CONTEXT *tdb, tdb_off offset, struct list_struct *rec)
-{
-       if (tdb_read(tdb, offset, rec, sizeof(*rec),DOCONV()) == -1)
-               return -1;
-       if (TDB_BAD_MAGIC(rec)) {
-               /* Ensure ecode is set for log fn. */
-               tdb->ecode = TDB_ERR_CORRUPT;
-               TDB_LOG((tdb, 0,"rec_read bad magic 0x%x at offset=%d\n", rec->magic, offset));
-               return TDB_ERRCODE(TDB_ERR_CORRUPT, -1);
-       }
-       return tdb_oob(tdb, rec->next+sizeof(*rec), 0);
-}
-static int rec_write(TDB_CONTEXT *tdb, tdb_off offset, struct list_struct *rec)
-{
-       struct list_struct r = *rec;
-       return tdb_write(tdb, offset, CONVERT(r), sizeof(r));
-}
-
-/* read a freelist record and check for simple errors */
-static int rec_free_read(TDB_CONTEXT *tdb, tdb_off off, struct list_struct *rec)
-{
-       if (tdb_read(tdb, off, rec, sizeof(*rec),DOCONV()) == -1)
-               return -1;
-
-       if (rec->magic == TDB_MAGIC) {
-               /* this happens when a app is showdown while deleting a record - we should
-                  not completely fail when this happens */
-               TDB_LOG((tdb, 0,"rec_free_read non-free magic 0x%x at offset=%d - fixing\n", 
-                        rec->magic, off));
-               rec->magic = TDB_FREE_MAGIC;
-               if (tdb_write(tdb, off, rec, sizeof(*rec)) == -1)
-                       return -1;
-       }
-
-       if (rec->magic != TDB_FREE_MAGIC) {
-               /* Ensure ecode is set for log fn. */
-               tdb->ecode = TDB_ERR_CORRUPT;
-               TDB_LOG((tdb, 0,"rec_free_read bad magic 0x%x at offset=%d\n", 
-                          rec->magic, off));
-               return TDB_ERRCODE(TDB_ERR_CORRUPT, -1);
-       }
-       if (tdb_oob(tdb, rec->next+sizeof(*rec), 0) != 0)
-               return -1;
-       return 0;
-}
-
-/* update a record tailer (must hold allocation lock) */
-static int update_tailer(TDB_CONTEXT *tdb, tdb_off offset,
-                        const struct list_struct *rec)
-{
-       tdb_off totalsize;
-
-       /* Offset of tailer from record header */
-       totalsize = sizeof(*rec) + rec->rec_len;
-       return ofs_write(tdb, offset + totalsize - sizeof(tdb_off),
-                        &totalsize);
-}
-
-static tdb_off tdb_dump_record(TDB_CONTEXT *tdb, tdb_off offset)
-{
-       struct list_struct rec;
-       tdb_off tailer_ofs, tailer;
-
-       if (tdb_read(tdb, offset, (char *)&rec, sizeof(rec), DOCONV()) == -1) {
-               printf("ERROR: failed to read record at %u\n", offset);
-               return 0;
-       }
-
-       printf(" rec: offset=%u next=%d rec_len=%d key_len=%d data_len=%d full_hash=0x%x magic=0x%x\n",
-              offset, rec.next, rec.rec_len, rec.key_len, rec.data_len, rec.full_hash, rec.magic);
-
-       tailer_ofs = offset + sizeof(rec) + rec.rec_len - sizeof(tdb_off);
-       if (ofs_read(tdb, tailer_ofs, &tailer) == -1) {
-               printf("ERROR: failed to read tailer at %u\n", tailer_ofs);
-               return rec.next;
-       }
-
-       if (tailer != rec.rec_len + sizeof(rec)) {
-               printf("ERROR: tailer does not match record! tailer=%u totalsize=%u\n",
-                               (unsigned)tailer, (unsigned)(rec.rec_len + sizeof(rec)));
-       }
-       return rec.next;
-}
-
-static int tdb_dump_chain(TDB_CONTEXT *tdb, int i)
-{
-       tdb_off rec_ptr, top;
-       int hash_length = 0;
-
-       top = TDB_HASH_TOP(i);
-
-       if (tdb_lock(tdb, i, F_WRLCK) != 0)
-               return -1;
-
-       if (ofs_read(tdb, top, &rec_ptr) == -1)
-               return tdb_unlock(tdb, i, F_WRLCK);
-
-       if (rec_ptr)
-               printf("hash=%d\n", i);
-
-       while (rec_ptr) {
-               rec_ptr = tdb_dump_record(tdb, rec_ptr);
-               hash_length += 1;
-       }
-
-       printf("chain %d length %d\n", i, hash_length);
-
-       return tdb_unlock(tdb, i, F_WRLCK);
-}
-
-void tdb_dump_all(TDB_CONTEXT *tdb)
-{
-       unsigned int i;
-       for (i=0;i<tdb->header.hash_size;i++) {
-               tdb_dump_chain(tdb, i);
-       }
-       tdb_printfreelist(tdb);
-}
-
-int tdb_printfreelist(TDB_CONTEXT *tdb)
-{
-       int ret;
-       long total_free = 0;
-       tdb_off offset, rec_ptr;
-       struct list_struct rec;
-
-       if ((ret = tdb_lock(tdb, -1, F_WRLCK)) != 0)
-               return ret;
-
-       offset = FREELIST_TOP;
-
-       /* read in the freelist top */
-       if (ofs_read(tdb, offset, &rec_ptr) == -1) {
-               tdb_unlock(tdb, -1, F_WRLCK);
-               return 0;
-       }
-
-       printf("freelist top=[0x%08x]\n", rec_ptr );
-       while (rec_ptr) {
-               if (tdb_read(tdb, rec_ptr, (char *)&rec, sizeof(rec), DOCONV()) == -1) {
-                       tdb_unlock(tdb, -1, F_WRLCK);
-                       return -1;
-               }
-
-               if (rec.magic != TDB_FREE_MAGIC) {
-                       printf("bad magic 0x%08x in free list\n", rec.magic);
-                       tdb_unlock(tdb, -1, F_WRLCK);
-                       return -1;
-               }
-
-               printf("entry offset=[0x%08x], rec.rec_len = [0x%08x (%d)]\n", rec.next, rec.rec_len, rec.rec_len );
-               total_free += rec.rec_len;
-
-               /* move to the next record */
-               rec_ptr = rec.next;
-       }
-       printf("total rec_len = [0x%08x (%d)]\n", (int)total_free, 
-               (int)total_free);
-
-       return tdb_unlock(tdb, -1, F_WRLCK);
-}
-
-/* Remove an element from the freelist.  Must have alloc lock. */
-static int remove_from_freelist(TDB_CONTEXT *tdb, tdb_off off, tdb_off next)
-{
-       tdb_off last_ptr, i;
-
-       /* read in the freelist top */
-       last_ptr = FREELIST_TOP;
-       while (ofs_read(tdb, last_ptr, &i) != -1 && i != 0) {
-               if (i == off) {
-                       /* We've found it! */
-                       return ofs_write(tdb, last_ptr, &next);
-               }
-               /* Follow chain (next offset is at start of record) */
-               last_ptr = i;
-       }
-       TDB_LOG((tdb, 0,"remove_from_freelist: not on list at off=%d\n", off));
-       return TDB_ERRCODE(TDB_ERR_CORRUPT, -1);
-}
-
-/* Add an element into the freelist. Merge adjacent records if
-   neccessary. */
-static int tdb_free(TDB_CONTEXT *tdb, tdb_off offset, struct list_struct *rec)
-{
-       tdb_off right, left;
-
-       /* Allocation and tailer lock */
-       if (tdb_lock(tdb, -1, F_WRLCK) != 0)
-               return -1;
-
-       /* set an initial tailer, so if we fail we don't leave a bogus record */
-       if (update_tailer(tdb, offset, rec) != 0) {
-               TDB_LOG((tdb, 0, "tdb_free: upfate_tailer failed!\n"));
-               goto fail;
-       }
-
-       /* Look right first (I'm an Australian, dammit) */
-       right = offset + sizeof(*rec) + rec->rec_len;
-       if (right + sizeof(*rec) <= tdb->map_size) {
-               struct list_struct r;
-
-               if (tdb_read(tdb, right, &r, sizeof(r), DOCONV()) == -1) {
-                       TDB_LOG((tdb, 0, "tdb_free: right read failed at %u\n", right));
-                       goto left;
-               }
-
-               /* If it's free, expand to include it. */
-               if (r.magic == TDB_FREE_MAGIC) {
-                       if (remove_from_freelist(tdb, right, r.next) == -1) {
-                               TDB_LOG((tdb, 0, "tdb_free: right free failed at %u\n", right));
-                               goto left;
-                       }
-                       rec->rec_len += sizeof(r) + r.rec_len;
-               }
-       }
-
-left:
-       /* Look left */
-       left = offset - sizeof(tdb_off);
-       if (left > TDB_DATA_START(tdb->header.hash_size)) {
-               struct list_struct l;
-               tdb_off leftsize;
-               
-               /* Read in tailer and jump back to header */
-               if (ofs_read(tdb, left, &leftsize) == -1) {
-                       TDB_LOG((tdb, 0, "tdb_free: left offset read failed at %u\n", left));
-                       goto update;
-               }
-               left = offset - leftsize;
-
-               /* Now read in record */
-               if (tdb_read(tdb, left, &l, sizeof(l), DOCONV()) == -1) {
-                       TDB_LOG((tdb, 0, "tdb_free: left read failed at %u (%u)\n", left, leftsize));
-                       goto update;
-               }
-
-               /* If it's free, expand to include it. */
-               if (l.magic == TDB_FREE_MAGIC) {
-                       if (remove_from_freelist(tdb, left, l.next) == -1) {
-                               TDB_LOG((tdb, 0, "tdb_free: left free failed at %u\n", left));
-                               goto update;
-                       } else {
-                               offset = left;
-                               rec->rec_len += leftsize;
-                       }
-               }
-       }
-
-update:
-       if (update_tailer(tdb, offset, rec) == -1) {
-               TDB_LOG((tdb, 0, "tdb_free: update_tailer failed at %u\n", offset));
-               goto fail;
-       }
-
-       /* Now, prepend to free list */
-       rec->magic = TDB_FREE_MAGIC;
-
-       if (ofs_read(tdb, FREELIST_TOP, &rec->next) == -1 ||
-           rec_write(tdb, offset, rec) == -1 ||
-           ofs_write(tdb, FREELIST_TOP, &offset) == -1) {
-               TDB_LOG((tdb, 0, "tdb_free record write failed at offset=%d\n", offset));
-               goto fail;
-       }
-
-       /* And we're done. */
-       tdb_unlock(tdb, -1, F_WRLCK);
-       return 0;
-
- fail:
-       tdb_unlock(tdb, -1, F_WRLCK);
-       return -1;
-}
-
-
-/* expand a file.  we prefer to use ftruncate, as that is what posix
-  says to use for mmap expansion */
-static int expand_file(TDB_CONTEXT *tdb, tdb_off size, tdb_off addition)
-{
-       char buf[1024];
-#ifdef HAVE_FTRUNCATE_EXTEND
-       if (ftruncate(tdb->fd, size+addition) != 0) {
-               TDB_LOG((tdb, 0, "expand_file ftruncate to %d failed (%s)\n", 
-                          size+addition, strerror(errno)));
-               return -1;
-       }
-#else
-       char b = 0;
-
-#ifdef HAVE_PWRITE
-       if (pwrite(tdb->fd,  &b, 1, (size+addition) - 1) != 1) {
-#else
-       if (lseek(tdb->fd, (size+addition) - 1, SEEK_SET) != (size+addition) - 1 || 
-           write(tdb->fd, &b, 1) != 1) {
-#endif
-               TDB_LOG((tdb, 0, "expand_file to %d failed (%s)\n", 
-                          size+addition, strerror(errno)));
-               return -1;
-       }
-#endif
-
-       /* now fill the file with something. This ensures that the file isn't sparse, which would be
-          very bad if we ran out of disk. This must be done with write, not via mmap */
-       memset(buf, 0x42, sizeof(buf));
-       while (addition) {
-               int n = addition>sizeof(buf)?sizeof(buf):addition;
-#ifdef HAVE_PWRITE
-               int ret = pwrite(tdb->fd, buf, n, size);
-#else
-               int ret;
-               if (lseek(tdb->fd, size, SEEK_SET) != size)
-                       return -1;
-               ret = write(tdb->fd, buf, n);
-#endif
-               if (ret != n) {
-                       TDB_LOG((tdb, 0, "expand_file write of %d failed (%s)\n", 
-                                  n, strerror(errno)));
-                       return -1;
-               }
-               addition -= n;
-               size += n;
-       }
-       return 0;
-}
-
-
-/* expand the database at least size bytes by expanding the underlying
-   file and doing the mmap again if necessary */
-static int tdb_expand(TDB_CONTEXT *tdb, tdb_off size)
-{
-       struct list_struct rec;
-       tdb_off offset;
-
-       if (tdb_lock(tdb, -1, F_WRLCK) == -1) {
-               TDB_LOG((tdb, 0, "lock failed in tdb_expand\n"));
-               return -1;
-       }
-
-       /* must know about any previous expansions by another process */
-       tdb_oob(tdb, tdb->map_size + 1, 1);
-
-       /* always make room for at least 10 more records, and round
-           the database up to a multiple of TDB_PAGE_SIZE */
-       size = TDB_ALIGN(tdb->map_size + size*10, TDB_PAGE_SIZE) - tdb->map_size;
-
-       if (!(tdb->flags & TDB_INTERNAL))
-               tdb_munmap(tdb);
-
-       /*
-        * We must ensure the file is unmapped before doing this
-        * to ensure consistency with systems like OpenBSD where
-        * writes and mmaps are not consistent.
-        */
-
-       /* expand the file itself */
-       if (!(tdb->flags & TDB_INTERNAL)) {
-               if (expand_file(tdb, tdb->map_size, size) != 0)
-                       goto fail;
-       }
-
-       tdb->map_size += size;
-
-       if (tdb->flags & TDB_INTERNAL) {
-               char *new_map_ptr = realloc(tdb->map_ptr, tdb->map_size);
-               if (!new_map_ptr) {
-                       tdb->map_size -= size;
-                       goto fail;
-               }
-               tdb->map_ptr = new_map_ptr;
-       } else {
-               /*
-                * We must ensure the file is remapped before adding the space
-                * to ensure consistency with systems like OpenBSD where
-                * writes and mmaps are not consistent.
-                */
-
-               /* We're ok if the mmap fails as we'll fallback to read/write */
-               tdb_mmap(tdb);
-       }
-
-       /* form a new freelist record */
-       memset(&rec,'\0',sizeof(rec));
-       rec.rec_len = size - sizeof(rec);
-
-       /* link it into the free list */
-       offset = tdb->map_size - size;
-       if (tdb_free(tdb, offset, &rec) == -1)
-               goto fail;
-
-       tdb_unlock(tdb, -1, F_WRLCK);
-       return 0;
- fail:
-       tdb_unlock(tdb, -1, F_WRLCK);
-       return -1;
-}
-
-/* allocate some space from the free list. The offset returned points
-   to a unconnected list_struct within the database with room for at
-   least length bytes of total data
-
-   0 is returned if the space could not be allocated
- */
-static tdb_off tdb_allocate(TDB_CONTEXT *tdb, tdb_len length,
-                           struct list_struct *rec)
-{
-       tdb_off rec_ptr, last_ptr, newrec_ptr;
-       struct list_struct newrec;
-
-       memset(&newrec, '\0', sizeof(newrec));
-
-       if (tdb_lock(tdb, -1, F_WRLCK) == -1)
-               return 0;
-
-       /* Extra bytes required for tailer */
-       length += sizeof(tdb_off);
-
- again:
-       last_ptr = FREELIST_TOP;
-
-       /* read in the freelist top */
-       if (ofs_read(tdb, FREELIST_TOP, &rec_ptr) == -1)
-               goto fail;
-
-       /* keep looking until we find a freelist record big enough */
-       while (rec_ptr) {
-               if (rec_free_read(tdb, rec_ptr, rec) == -1)
-                       goto fail;
-
-               if (rec->rec_len >= length) {
-                       /* found it - now possibly split it up  */
-                       if (rec->rec_len > length + MIN_REC_SIZE) {
-                               /* Length of left piece */
-                               length = TDB_ALIGN(length, TDB_ALIGNMENT);
-
-                               /* Right piece to go on free list */
-                               newrec.rec_len = rec->rec_len
-                                       - (sizeof(*rec) + length);
-                               newrec_ptr = rec_ptr + sizeof(*rec) + length;
-
-                               /* And left record is shortened */
-                               rec->rec_len = length;
-                       } else
-                               newrec_ptr = 0;
-
-                       /* Remove allocated record from the free list */
-                       if (ofs_write(tdb, last_ptr, &rec->next) == -1)
-                               goto fail;
-
-                       /* Update header: do this before we drop alloc
-                           lock, otherwise tdb_free() might try to
-                           merge with us, thinking we're free.
-                           (Thanks Jeremy Allison). */
-                       rec->magic = TDB_MAGIC;
-                       if (rec_write(tdb, rec_ptr, rec) == -1)
-                               goto fail;
-
-                       /* Did we create new block? */
-                       if (newrec_ptr) {
-                               /* Update allocated record tailer (we
-                                   shortened it). */
-                               if (update_tailer(tdb, rec_ptr, rec) == -1)
-                                       goto fail;
-
-                               /* Free new record */
-                               if (tdb_free(tdb, newrec_ptr, &newrec) == -1)
-                                       goto fail;
-                       }
-
-                       /* all done - return the new record offset */
-                       tdb_unlock(tdb, -1, F_WRLCK);
-                       return rec_ptr;
-               }
-               /* move to the next record */
-               last_ptr = rec_ptr;
-               rec_ptr = rec->next;
-       }
-       /* we didn't find enough space. See if we can expand the
-          database and if we can then try again */
-       if (tdb_expand(tdb, length + sizeof(*rec)) == 0)
-               goto again;
- fail:
-       tdb_unlock(tdb, -1, F_WRLCK);
-       return 0;
-}
-
-/* initialise a new database with a specified hash size */
-static int tdb_new_database(TDB_CONTEXT *tdb, int hash_size)
-{
-       struct tdb_header *newdb;
-       int size, ret = -1;
-
-       /* We make it up in memory, then write it out if not internal */
-       size = sizeof(struct tdb_header) + (hash_size+1)*sizeof(tdb_off);
-       if (!(newdb = calloc(size, 1)))
-               return TDB_ERRCODE(TDB_ERR_OOM, -1);
-
-       /* Fill in the header */
-       newdb->version = TDB_VERSION;
-       newdb->hash_size = hash_size;
-#ifdef USE_SPINLOCKS
-       newdb->rwlocks = size;
-#endif
-       if (tdb->flags & TDB_INTERNAL) {
-               tdb->map_size = size;
-               tdb->map_ptr = (char *)newdb;
-               memcpy(&tdb->header, newdb, sizeof(tdb->header));
-               /* Convert the `ondisk' version if asked. */
-               CONVERT(*newdb);
-               return 0;
-       }
-       if (lseek(tdb->fd, 0, SEEK_SET) == -1)
-               goto fail;
-
-       if (ftruncate(tdb->fd, 0) == -1)
-               goto fail;
-
-       /* This creates an endian-converted header, as if read from disk */
-       CONVERT(*newdb);
-       memcpy(&tdb->header, newdb, sizeof(tdb->header));
-       /* Don't endian-convert the magic food! */
-       memcpy(newdb->magic_food, TDB_MAGIC_FOOD, strlen(TDB_MAGIC_FOOD)+1);
-       if (write(tdb->fd, newdb, size) != size)
-               ret = -1;
-       else
-               ret = tdb_create_rwlocks(tdb->fd, hash_size);
-
-  fail:
-       SAFE_FREE(newdb);
-       return ret;
-}
-
-/* Returns 0 on fail.  On success, return offset of record, and fills
-   in rec */
-static tdb_off tdb_find(TDB_CONTEXT *tdb, TDB_DATA key, u32 hash,
-                       struct list_struct *r)
-{
-       tdb_off rec_ptr;
-       
-       /* read in the hash top */
-       if (ofs_read(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1)
-               return 0;
-
-       /* keep looking until we find the right record */
-       while (rec_ptr) {
-               if (rec_read(tdb, rec_ptr, r) == -1)
-                       return 0;
-
-               if (!TDB_DEAD(r) && hash==r->full_hash && key.dsize==r->key_len) {
-                       char *k;
-                       /* a very likely hit - read the key */
-                       k = tdb_alloc_read(tdb, rec_ptr + sizeof(*r), 
-                                          r->key_len);
-                       if (!k)
-                               return 0;
-
-                       if (memcmp(key.dptr, k, key.dsize) == 0) {
-                               SAFE_FREE(k);
-                               return rec_ptr;
-                       }
-                       SAFE_FREE(k);
-               }
-               rec_ptr = r->next;
-       }
-       return TDB_ERRCODE(TDB_ERR_NOEXIST, 0);
-}
-
-/* As tdb_find, but if you succeed, keep the lock */
-static tdb_off tdb_find_lock_hash(TDB_CONTEXT *tdb, TDB_DATA key, u32 hash, int locktype,
-                            struct list_struct *rec)
-{
-       u32 rec_ptr;
-
-       if (tdb_lock(tdb, BUCKET(hash), locktype) == -1)
-               return 0;
-       if (!(rec_ptr = tdb_find(tdb, key, hash, rec)))
-               tdb_unlock(tdb, BUCKET(hash), locktype);
-       return rec_ptr;
-}
-
-enum TDB_ERROR tdb_error(TDB_CONTEXT *tdb)
-{
-       return tdb->ecode;
-}
-
-static struct tdb_errname {
-       enum TDB_ERROR ecode; const char *estring;
-} emap[] = { {TDB_SUCCESS, "Success"},
-            {TDB_ERR_CORRUPT, "Corrupt database"},
-            {TDB_ERR_IO, "IO Error"},
-            {TDB_ERR_LOCK, "Locking error"},
-            {TDB_ERR_OOM, "Out of memory"},
-            {TDB_ERR_EXISTS, "Record exists"},
-            {TDB_ERR_NOLOCK, "Lock exists on other keys"},
-            {TDB_ERR_NOEXIST, "Record does not exist"} };
-
-/* Error string for the last tdb error */
-const char *tdb_errorstr(TDB_CONTEXT *tdb)
-{
-       u32 i;
-       for (i = 0; i < sizeof(emap) / sizeof(struct tdb_errname); i++)
-               if (tdb->ecode == emap[i].ecode)
-                       return emap[i].estring;
-       return "Invalid error code";
-}
-
-/* update an entry in place - this only works if the new data size
-   is <= the old data size and the key exists.
-   on failure return -1.
-*/
-
-static int tdb_update_hash(TDB_CONTEXT *tdb, TDB_DATA key, u32 hash, TDB_DATA dbuf)
-{
-       struct list_struct rec;
-       tdb_off rec_ptr;
-
-       /* find entry */
-       if (!(rec_ptr = tdb_find(tdb, key, hash, &rec)))
-               return -1;
-
-       /* must be long enough key, data and tailer */
-       if (rec.rec_len < key.dsize + dbuf.dsize + sizeof(tdb_off)) {
-               tdb->ecode = TDB_SUCCESS; /* Not really an error */
-               return -1;
-       }
-
-       if (tdb_write(tdb, rec_ptr + sizeof(rec) + rec.key_len,
-                     dbuf.dptr, dbuf.dsize) == -1)
-               return -1;
-
-       if (dbuf.dsize != rec.data_len) {
-               /* update size */
-               rec.data_len = dbuf.dsize;
-               return rec_write(tdb, rec_ptr, &rec);
-       }
-       return 0;
-}
-
-/* find an entry in the database given a key */
-/* If an entry doesn't exist tdb_err will be set to
- * TDB_ERR_NOEXIST. If a key has no data attached
- * tdb_err will not be set. Both will return a
- * zero pptr and zero dsize.
- */
-
-TDB_DATA tdb_fetch(TDB_CONTEXT *tdb, TDB_DATA key)
-{
-       tdb_off rec_ptr;
-       struct list_struct rec;
-       TDB_DATA ret;
-       u32 hash;
-
-       /* find which hash bucket it is in */
-       hash = tdb->hash_fn(&key);
-       if (!(rec_ptr = tdb_find_lock_hash(tdb,key,hash,F_RDLCK,&rec)))
-               return tdb_null;
-
-       if (rec.data_len)
-               ret.dptr = tdb_alloc_read(tdb, rec_ptr + sizeof(rec) + rec.key_len,
-                                         rec.data_len);
-       else
-               ret.dptr = NULL;
-       ret.dsize = rec.data_len;
-       tdb_unlock(tdb, BUCKET(rec.full_hash), F_RDLCK);
-       return ret;
-}
-
-/* check if an entry in the database exists 
-
-   note that 1 is returned if the key is found and 0 is returned if not found
-   this doesn't match the conventions in the rest of this module, but is
-   compatible with gdbm
-*/
-static int tdb_exists_hash(TDB_CONTEXT *tdb, TDB_DATA key, u32 hash)
-{
-       struct list_struct rec;
-       
-       if (tdb_find_lock_hash(tdb, key, hash, F_RDLCK, &rec) == 0)
-               return 0;
-       tdb_unlock(tdb, BUCKET(rec.full_hash), F_RDLCK);
-       return 1;
-}
-
-int tdb_exists(TDB_CONTEXT *tdb, TDB_DATA key)
-{
-       u32 hash = tdb->hash_fn(&key);
-       return tdb_exists_hash(tdb, key, hash);
-}
-
-/* record lock stops delete underneath */
-static int lock_record(TDB_CONTEXT *tdb, tdb_off off)
-{
-       return off ? tdb_brlock(tdb, off, F_RDLCK, F_SETLKW, 0) : 0;
-}
-/*
-  Write locks override our own fcntl readlocks, so check it here.
-  Note this is meant to be F_SETLK, *not* F_SETLKW, as it's not
-  an error to fail to get the lock here.
-*/
-static int write_lock_record(TDB_CONTEXT *tdb, tdb_off off)
-{
-       struct tdb_traverse_lock *i;
-       for (i = &tdb->travlocks; i; i = i->next)
-               if (i->off == off)
-                       return -1;
-       return tdb_brlock(tdb, off, F_WRLCK, F_SETLK, 1);
-}
-
-/*
-  Note this is meant to be F_SETLK, *not* F_SETLKW, as it's not
-  an error to fail to get the lock here.
-*/
-
-static int write_unlock_record(TDB_CONTEXT *tdb, tdb_off off)
-{
-       return tdb_brlock(tdb, off, F_UNLCK, F_SETLK, 0);
-}
-/* fcntl locks don't stack: avoid unlocking someone else's */
-static int unlock_record(TDB_CONTEXT *tdb, tdb_off off)
-{
-       struct tdb_traverse_lock *i;
-       u32 count = 0;
-
-       if (off == 0)
-               return 0;
-       for (i = &tdb->travlocks; i; i = i->next)
-               if (i->off == off)
-                       count++;
-       return (count == 1 ? tdb_brlock(tdb, off, F_UNLCK, F_SETLKW, 0) : 0);
-}
-
-/* actually delete an entry in the database given the offset */
-static int do_delete(TDB_CONTEXT *tdb, tdb_off rec_ptr, struct list_struct*rec)
-{
-       tdb_off last_ptr, i;
-       struct list_struct lastrec;
-
-       if (tdb->read_only) return -1;
-
-       if (write_lock_record(tdb, rec_ptr) == -1) {
-               /* Someone traversing here: mark it as dead */
-               rec->magic = TDB_DEAD_MAGIC;
-               return rec_write(tdb, rec_ptr, rec);
-       }
-       if (write_unlock_record(tdb, rec_ptr) != 0)
-               return -1;
-
-       /* find previous record in hash chain */
-       if (ofs_read(tdb, TDB_HASH_TOP(rec->full_hash), &i) == -1)
-               return -1;
-       for (last_ptr = 0; i != rec_ptr; last_ptr = i, i = lastrec.next)
-               if (rec_read(tdb, i, &lastrec) == -1)
-                       return -1;
-
-       /* unlink it: next ptr is at start of record. */
-       if (last_ptr == 0)
-               last_ptr = TDB_HASH_TOP(rec->full_hash);
-       if (ofs_write(tdb, last_ptr, &rec->next) == -1)
-               return -1;
-
-       /* recover the space */
-       if (tdb_free(tdb, rec_ptr, rec) == -1)
-               return -1;
-       return 0;
-}
-
-/* Uses traverse lock: 0 = finish, -1 = error, other = record offset */
-static int tdb_next_lock(TDB_CONTEXT *tdb, struct tdb_traverse_lock *tlock,
-                        struct list_struct *rec)
-{
-       int want_next = (tlock->off != 0);
-
-       /* Lock each chain from the start one. */
-       for (; tlock->hash < tdb->header.hash_size; tlock->hash++) {
-
-               /* this is an optimisation for the common case where
-                  the hash chain is empty, which is particularly
-                  common for the use of tdb with ldb, where large
-                  hashes are used. In that case we spend most of our
-                  time in tdb_brlock(), locking empty hash chains.
-
-                  To avoid this, we do an unlocked pre-check to see
-                  if the hash chain is empty before starting to look
-                  inside it. If it is empty then we can avoid that
-                  hash chain. If it isn't empty then we can't believe
-                  the value we get back, as we read it without a
-                  lock, so instead we get the lock and re-fetch the
-                  value below.
-
-                  Notice that not doing this optimisation on the
-                  first hash chain is critical. We must guarantee
-                  that we have done at least one fcntl lock at the
-                  start of a search to guarantee that memory is
-                  coherent on SMP systems. If records are added by
-                  others during the search then thats OK, and we
-                  could possibly miss those with this trick, but we
-                  could miss them anyway without this trick, so the
-                  semantics don't change.
-
-                  With a non-indexed ldb search this trick gains us a
-                  factor of around 80 in speed on a linux 2.6.x
-                  system (testing using ldbtest).
-                */
-               if (!tlock->off && tlock->hash != 0) {
-                       u32 off;
-                       if (tdb->map_ptr) {
-                               for (;tlock->hash < tdb->header.hash_size;tlock->hash++) {
-                                       if (0 != *(u32 *)(TDB_HASH_TOP(tlock->hash) + (unsigned char *)tdb->map_ptr)) {
-                                               break;
-                                       }
-                               }
-                               if (tlock->hash == tdb->header.hash_size) {
-                                       continue;
-                               }
-                       } else {
-                               if (ofs_read(tdb, TDB_HASH_TOP(tlock->hash), &off) == 0 &&
-                                   off == 0) {
-                                       continue;
-                               }
-                       }
-               }
-
-               if (tdb_lock(tdb, tlock->hash, F_WRLCK) == -1)
-                       return -1;
-
-               /* No previous record?  Start at top of chain. */
-               if (!tlock->off) {
-                       if (ofs_read(tdb, TDB_HASH_TOP(tlock->hash),
-                                    &tlock->off) == -1)
-                               goto fail;
-               } else {
-                       /* Otherwise unlock the previous record. */
-                       if (unlock_record(tdb, tlock->off) != 0)
-                               goto fail;
-               }
-
-               if (want_next) {
-                       /* We have offset of old record: grab next */
-                       if (rec_read(tdb, tlock->off, rec) == -1)
-                               goto fail;
-                       tlock->off = rec->next;
-               }
-
-               /* Iterate through chain */
-               while( tlock->off) {
-                       tdb_off current;
-                       if (rec_read(tdb, tlock->off, rec) == -1)
-                               goto fail;
-
-                       /* Detect infinite loops. From "Shlomi Yaakobovich" <Shlomi@exanet.com>. */
-                       if (tlock->off == rec->next) {
-                               TDB_LOG((tdb, 0, "tdb_next_lock: loop detected.\n"));
-                               goto fail;
-                       }
-
-                       if (!TDB_DEAD(rec)) {
-                               /* Woohoo: we found one! */
-                               if (lock_record(tdb, tlock->off) != 0)
-                                       goto fail;
-                               return tlock->off;
-                       }
-
-                       /* Try to clean dead ones from old traverses */
-                       current = tlock->off;
-                       tlock->off = rec->next;
-                       if (!tdb->read_only && 
-                           do_delete(tdb, current, rec) != 0)
-                               goto fail;
-               }
-               tdb_unlock(tdb, tlock->hash, F_WRLCK);
-               want_next = 0;
-       }
-       /* We finished iteration without finding anything */
-       return TDB_ERRCODE(TDB_SUCCESS, 0);
-
- fail:
-       tlock->off = 0;
-       if (tdb_unlock(tdb, tlock->hash, F_WRLCK) != 0)
-               TDB_LOG((tdb, 0, "tdb_next_lock: On error unlock failed!\n"));
-       return -1;
-}
-
-/* traverse the entire database - calling fn(tdb, key, data) on each element.
-   return -1 on error or the record count traversed
-   if fn is NULL then it is not called
-   a non-zero return value from fn() indicates that the traversal should stop
-  */
-int tdb_traverse(TDB_CONTEXT *tdb, tdb_traverse_func fn, void *private_val)
-{
-       TDB_DATA key, dbuf;
-       struct list_struct rec;
-       struct tdb_traverse_lock tl = { NULL, 0, 0 };
-       int ret, count = 0;
-
-       /* This was in the initializaton, above, but the IRIX compiler
-        * did not like it.  crh
-        */
-       tl.next = tdb->travlocks.next;
-
-       /* fcntl locks don't stack: beware traverse inside traverse */
-       tdb->travlocks.next = &tl;
-
-       /* tdb_next_lock places locks on the record returned, and its chain */
-       while ((ret = tdb_next_lock(tdb, &tl, &rec)) > 0) {
-               count++;
-               /* now read the full record */
-               key.dptr = tdb_alloc_read(tdb, tl.off + sizeof(rec), 
-                                         rec.key_len + rec.data_len);
-               if (!key.dptr) {
-                       ret = -1;
-                       if (tdb_unlock(tdb, tl.hash, F_WRLCK) != 0)
-                               goto out;
-                       if (unlock_record(tdb, tl.off) != 0)
-                               TDB_LOG((tdb, 0, "tdb_traverse: key.dptr == NULL and unlock_record failed!\n"));
-                       goto out;
-               }
-               key.dsize = rec.key_len;
-               dbuf.dptr = key.dptr + rec.key_len;
-               dbuf.dsize = rec.data_len;
-
-               /* Drop chain lock, call out */
-               if (tdb_unlock(tdb, tl.hash, F_WRLCK) != 0) {
-                       ret = -1;
-                       goto out;
-               }
-               if (fn && fn(tdb, key, dbuf, private_val)) {
-                       /* They want us to terminate traversal */
-                       ret = count;
-                       if (unlock_record(tdb, tl.off) != 0) {
-                               TDB_LOG((tdb, 0, "tdb_traverse: unlock_record failed!\n"));;
-                               ret = -1;
-                       }
-                       tdb->travlocks.next = tl.next;
-                       SAFE_FREE(key.dptr);
-                       return count;
-               }
-               SAFE_FREE(key.dptr);
-       }
-out:
-       tdb->travlocks.next = tl.next;
-       if (ret < 0)
-               return -1;
-       else
-               return count;
-}
-
-/* find the first entry in the database and return its key */
-TDB_DATA tdb_firstkey(TDB_CONTEXT *tdb)
-{
-       TDB_DATA key;
-       struct list_struct rec;
-
-       /* release any old lock */
-       if (unlock_record(tdb, tdb->travlocks.off) != 0)
-               return tdb_null;
-       tdb->travlocks.off = tdb->travlocks.hash = 0;
-
-       if (tdb_next_lock(tdb, &tdb->travlocks, &rec) <= 0)
-               return tdb_null;
-       /* now read the key */
-       key.dsize = rec.key_len;
-       key.dptr =tdb_alloc_read(tdb,tdb->travlocks.off+sizeof(rec),key.dsize);
-       if (tdb_unlock(tdb, BUCKET(tdb->travlocks.hash), F_WRLCK) != 0)
-               TDB_LOG((tdb, 0, "tdb_firstkey: error occurred while tdb_unlocking!\n"));
-       return key;
-}
-
-/* find the next entry in the database, returning its key */
-TDB_DATA tdb_nextkey(TDB_CONTEXT *tdb, TDB_DATA oldkey)
-{
-       u32 oldhash;
-       TDB_DATA key = tdb_null;
-       struct list_struct rec;
-       char *k = NULL;
-
-       /* Is locked key the old key?  If so, traverse will be reliable. */
-       if (tdb->travlocks.off) {
-               if (tdb_lock(tdb,tdb->travlocks.hash,F_WRLCK))
-                       return tdb_null;
-               if (rec_read(tdb, tdb->travlocks.off, &rec) == -1
-                   || !(k = tdb_alloc_read(tdb,tdb->travlocks.off+sizeof(rec),
-                                           rec.key_len))
-                   || memcmp(k, oldkey.dptr, oldkey.dsize) != 0) {
-                       /* No, it wasn't: unlock it and start from scratch */
-                       if (unlock_record(tdb, tdb->travlocks.off) != 0)
-                               return tdb_null;
-                       if (tdb_unlock(tdb, tdb->travlocks.hash, F_WRLCK) != 0)
-                               return tdb_null;
-                       tdb->travlocks.off = 0;
-               }
-
-               SAFE_FREE(k);
-       }
-
-       if (!tdb->travlocks.off) {
-               /* No previous element: do normal find, and lock record */
-               tdb->travlocks.off = tdb_find_lock_hash(tdb, oldkey, tdb->hash_fn(&oldkey), F_WRLCK, &rec);
-               if (!tdb->travlocks.off)
-                       return tdb_null;
-               tdb->travlocks.hash = BUCKET(rec.full_hash);
-               if (lock_record(tdb, tdb->travlocks.off) != 0) {
-                       TDB_LOG((tdb, 0, "tdb_nextkey: lock_record failed (%s)!\n", strerror(errno)));
-                       return tdb_null;
-               }
-       }
-       oldhash = tdb->travlocks.hash;
-
-       /* Grab next record: locks chain and returned record,
-          unlocks old record */
-       if (tdb_next_lock(tdb, &tdb->travlocks, &rec) > 0) {
-               key.dsize = rec.key_len;
-               key.dptr = tdb_alloc_read(tdb, tdb->travlocks.off+sizeof(rec),
-                                         key.dsize);
-               /* Unlock the chain of this new record */
-               if (tdb_unlock(tdb, tdb->travlocks.hash, F_WRLCK) != 0)
-                       TDB_LOG((tdb, 0, "tdb_nextkey: WARNING tdb_unlock failed!\n"));
-       }
-       /* Unlock the chain of old record */
-       if (tdb_unlock(tdb, BUCKET(oldhash), F_WRLCK) != 0)
-               TDB_LOG((tdb, 0, "tdb_nextkey: WARNING tdb_unlock failed!\n"));
-       return key;
-}
-
-/* delete an entry in the database given a key */
-static int tdb_delete_hash(TDB_CONTEXT *tdb, TDB_DATA key, u32 hash)
-{
-       tdb_off rec_ptr;
-       struct list_struct rec;
-       int ret;
-
-       if (!(rec_ptr = tdb_find_lock_hash(tdb, key, hash, F_WRLCK, &rec)))
-               return -1;
-       ret = do_delete(tdb, rec_ptr, &rec);
-       if (tdb_unlock(tdb, BUCKET(rec.full_hash), F_WRLCK) != 0)
-               TDB_LOG((tdb, 0, "tdb_delete: WARNING tdb_unlock failed!\n"));
-       return ret;
-}
-
-int tdb_delete(TDB_CONTEXT *tdb, TDB_DATA key)
-{
-       u32 hash = tdb->hash_fn(&key);
-       return tdb_delete_hash(tdb, key, hash);
-}
-
-/* store an element in the database, replacing any existing element
-   with the same key 
-
-   return 0 on success, -1 on failure
-*/
-int tdb_store(TDB_CONTEXT *tdb, TDB_DATA key, TDB_DATA dbuf, int flag)
-{
-       struct list_struct rec;
-       u32 hash;
-       tdb_off rec_ptr;
-       char *p = NULL;
-       int ret = 0;
-
-       /* find which hash bucket it is in */
-       hash = tdb->hash_fn(&key);
-       if (tdb_lock(tdb, BUCKET(hash), F_WRLCK) == -1)
-               return -1;
-
-       /* check for it existing, on insert. */
-       if (flag == TDB_INSERT) {
-               if (tdb_exists_hash(tdb, key, hash)) {
-                       tdb->ecode = TDB_ERR_EXISTS;
-                       goto fail;
-               }
-       } else {
-               /* first try in-place update, on modify or replace. */
-               if (tdb_update_hash(tdb, key, hash, dbuf) == 0)
-                       goto out;
-               if (tdb->ecode == TDB_ERR_NOEXIST &&
-                   flag == TDB_MODIFY) {
-                       /* if the record doesn't exist and we are in TDB_MODIFY mode then
-                        we should fail the store */
-                       goto fail;
-       }
-       }
-       /* reset the error code potentially set by the tdb_update() */
-       tdb->ecode = TDB_SUCCESS;
-
-       /* delete any existing record - if it doesn't exist we don't
-           care.  Doing this first reduces fragmentation, and avoids
-           coalescing with `allocated' block before it's updated. */
-       if (flag != TDB_INSERT)
-               tdb_delete_hash(tdb, key, hash);
-
-       /* Copy key+value *before* allocating free space in case malloc
-          fails and we are left with a dead spot in the tdb. */
-
-       if (!(p = (char *)malloc(key.dsize + dbuf.dsize))) {
-               tdb->ecode = TDB_ERR_OOM;
-               goto fail;
-       }
-
-       memcpy(p, key.dptr, key.dsize);
-       if (dbuf.dsize)
-               memcpy(p+key.dsize, dbuf.dptr, dbuf.dsize);
-
-       /* we have to allocate some space */
-       if (!(rec_ptr = tdb_allocate(tdb, key.dsize + dbuf.dsize, &rec)))
-               goto fail;
-
-       /* Read hash top into next ptr */
-       if (ofs_read(tdb, TDB_HASH_TOP(hash), &rec.next) == -1)
-               goto fail;
-
-       rec.key_len = key.dsize;
-       rec.data_len = dbuf.dsize;
-       rec.full_hash = hash;
-       rec.magic = TDB_MAGIC;
-
-       /* write out and point the top of the hash chain at it */
-       if (rec_write(tdb, rec_ptr, &rec) == -1
-           || tdb_write(tdb, rec_ptr+sizeof(rec), p, key.dsize+dbuf.dsize)==-1
-           || ofs_write(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1) {
-               /* Need to tdb_unallocate() here */
-               goto fail;
-       }
- out:
-       SAFE_FREE(p); 
-       tdb_unlock(tdb, BUCKET(hash), F_WRLCK);
-       return ret;
-fail:
-       ret = -1;
-       goto out;
-}
-
-/* Attempt to append data to an entry in place - this only works if the new data size
-   is <= the old data size and the key exists.
-   on failure return -1. Record must be locked before calling.
-*/
-static int tdb_append_inplace(TDB_CONTEXT *tdb, TDB_DATA key, u32 hash, TDB_DATA new_dbuf)
-{
-       struct list_struct rec;
-       tdb_off rec_ptr;
-
-       /* find entry */
-       if (!(rec_ptr = tdb_find(tdb, key, hash, &rec)))
-               return -1;
-
-       /* Append of 0 is always ok. */
-       if (new_dbuf.dsize == 0)
-               return 0;
-
-       /* must be long enough for key, old data + new data and tailer */
-       if (rec.rec_len < key.dsize + rec.data_len + new_dbuf.dsize + sizeof(tdb_off)) {
-               /* No room. */
-               tdb->ecode = TDB_SUCCESS; /* Not really an error */
-               return -1;
-       }
-
-       if (tdb_write(tdb, rec_ptr + sizeof(rec) + rec.key_len + rec.data_len,
-                     new_dbuf.dptr, new_dbuf.dsize) == -1)
-               return -1;
-
-       /* update size */
-       rec.data_len += new_dbuf.dsize;
-       return rec_write(tdb, rec_ptr, &rec);
-}
-
-/* Append to an entry. Create if not exist. */
-
-int tdb_append(TDB_CONTEXT *tdb, TDB_DATA key, TDB_DATA new_dbuf)
-{
-       struct list_struct rec;
-       u32 hash;
-       tdb_off rec_ptr;
-       char *p = NULL;
-       int ret = 0;
-       size_t new_data_size = 0;
-
-       /* find which hash bucket it is in */
-       hash = tdb->hash_fn(&key);
-       if (tdb_lock(tdb, BUCKET(hash), F_WRLCK) == -1)
-               return -1;
-
-       /* first try in-place. */
-       if (tdb_append_inplace(tdb, key, hash, new_dbuf) == 0)
-               goto out;
-
-       /* reset the error code potentially set by the tdb_append_inplace() */
-       tdb->ecode = TDB_SUCCESS;
-
-       /* find entry */
-       if (!(rec_ptr = tdb_find(tdb, key, hash, &rec))) {
-               if (tdb->ecode != TDB_ERR_NOEXIST)
-                       goto fail;
-
-               /* Not found - create. */
-
-               ret = tdb_store(tdb, key, new_dbuf, TDB_INSERT);
-               goto out;
-       }
-
-       new_data_size = rec.data_len + new_dbuf.dsize;
-
-       /* Copy key+old_value+value *before* allocating free space in case malloc
-          fails and we are left with a dead spot in the tdb. */
-
-       if (!(p = (char *)malloc(key.dsize + new_data_size))) {
-               tdb->ecode = TDB_ERR_OOM;
-               goto fail;
-       }
-
-       /* Copy the key in place. */
-       memcpy(p, key.dptr, key.dsize);
-
-       /* Now read the old data into place. */
-       if (rec.data_len &&
-               tdb_read(tdb, rec_ptr + sizeof(rec) + rec.key_len, p + key.dsize, rec.data_len, 0) == -1)
-                       goto fail;
-
-       /* Finally append the new data. */
-       if (new_dbuf.dsize)
-               memcpy(p+key.dsize+rec.data_len, new_dbuf.dptr, new_dbuf.dsize);
-
-       /* delete any existing record - if it doesn't exist we don't
-           care.  Doing this first reduces fragmentation, and avoids
-           coalescing with `allocated' block before it's updated. */
-
-       tdb_delete_hash(tdb, key, hash);
-
-       if (!(rec_ptr = tdb_allocate(tdb, key.dsize + new_data_size, &rec)))
-               goto fail;
-
-       /* Read hash top into next ptr */
-       if (ofs_read(tdb, TDB_HASH_TOP(hash), &rec.next) == -1)
-               goto fail;
-
-       rec.key_len = key.dsize;
-       rec.data_len = new_data_size;
-       rec.full_hash = hash;
-       rec.magic = TDB_MAGIC;
-
-       /* write out and point the top of the hash chain at it */
-       if (rec_write(tdb, rec_ptr, &rec) == -1
-           || tdb_write(tdb, rec_ptr+sizeof(rec), p, key.dsize+new_data_size)==-1
-           || ofs_write(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1) {
-               /* Need to tdb_unallocate() here */
-               goto fail;
-       }
-
- out:
-       SAFE_FREE(p); 
-       tdb_unlock(tdb, BUCKET(hash), F_WRLCK);
-       return ret;
-
-fail:
-       ret = -1;
-       goto out;
-}
-
-static int tdb_already_open(dev_t device,
-                           ino_t ino)
-{
-       TDB_CONTEXT *i;
-       
-       for (i = tdbs; i; i = i->next) {
-               if (i->device == device && i->inode == ino) {
-                       return 1;
-               }
-       }
-
-       return 0;
-}
-
-/* This is based on the hash algorithm from gdbm */
-static u32 default_tdb_hash(TDB_DATA *key)
-{
-       u32 value;      /* Used to compute the hash value.  */
-       u32   i;        /* Used to cycle through random values. */
-
-       /* Set the initial value from the key size. */
-       for (value = 0x238F13AF * key->dsize, i=0; i < key->dsize; i++)
-               value = (value + (key->dptr[i] << (i*5 % 24)));
-
-       return (1103515243 * value + 12345);  
-}
-
-/* open the database, creating it if necessary 
-
-   The open_flags and mode are passed straight to the open call on the
-   database file. A flags value of O_WRONLY is invalid. The hash size
-   is advisory, use zero for a default value.
-
-   Return is NULL on error, in which case errno is also set.  Don't 
-   try to call tdb_error or tdb_errname, just do strerror(errno).
-
-   @param name may be NULL for internal databases. */
-TDB_CONTEXT *tdb_open(const char *name, int hash_size, int tdb_flags,
-                     int open_flags, mode_t mode)
-{
-       return tdb_open_ex(name, hash_size, tdb_flags, open_flags, mode, NULL, NULL);
-}
-
-
-TDB_CONTEXT *tdb_open_ex(const char *name, int hash_size, int tdb_flags,
-                        int open_flags, mode_t mode,
-                        tdb_log_func log_fn,
-                        tdb_hash_func hash_fn)
-{
-       TDB_CONTEXT *tdb;
-       struct stat st;
-       int rev = 0, locked = 0;
-       unsigned char *vp;
-       u32 vertest;
-
-       if (!(tdb = calloc(1, sizeof *tdb))) {
-               /* Can't log this */
-               errno = ENOMEM;
-               goto fail;
-       }
-       tdb->fd = -1;
-       tdb->name = NULL;
-       tdb->map_ptr = NULL;
-       tdb->flags = tdb_flags;
-       tdb->open_flags = open_flags;
-       tdb->log_fn = log_fn;
-       tdb->hash_fn = hash_fn ? hash_fn : default_tdb_hash;
-
-       if ((open_flags & O_ACCMODE) == O_WRONLY) {
-               TDB_LOG((tdb, 0, "tdb_open_ex: can't open tdb %s write-only\n",
-                        name));
-               errno = EINVAL;
-               goto fail;
-       }
-       
-       if (hash_size == 0)
-               hash_size = DEFAULT_HASH_SIZE;
-       if ((open_flags & O_ACCMODE) == O_RDONLY) {
-               tdb->read_only = 1;
-               /* read only databases don't do locking or clear if first */
-               tdb->flags |= TDB_NOLOCK;
-               tdb->flags &= ~TDB_CLEAR_IF_FIRST;
-       }
-
-       /* internal databases don't mmap or lock, and start off cleared */
-       if (tdb->flags & TDB_INTERNAL) {
-               tdb->flags |= (TDB_NOLOCK | TDB_NOMMAP);
-               tdb->flags &= ~TDB_CLEAR_IF_FIRST;
-               if (tdb_new_database(tdb, hash_size) != 0) {
-                       TDB_LOG((tdb, 0, "tdb_open_ex: tdb_new_database failed!"));
-                       goto fail;
-               }
-               goto internal;
-       }
-
-       if ((tdb->fd = open(name, open_flags, mode)) == -1) {
-               TDB_LOG((tdb, 5, "tdb_open_ex: could not open file %s: %s\n",
-                        name, strerror(errno)));
-               goto fail;      /* errno set by open(2) */
-       }
-
-       /* ensure there is only one process initialising at once */
-       if (tdb_brlock(tdb, GLOBAL_LOCK, F_WRLCK, F_SETLKW, 0) == -1) {
-               TDB_LOG((tdb, 0, "tdb_open_ex: failed to get global lock on %s: %s\n",
-                        name, strerror(errno)));
-               goto fail;      /* errno set by tdb_brlock */
-       }
-
-       /* we need to zero database if we are the only one with it open */
-       if ((tdb_flags & TDB_CLEAR_IF_FIRST) &&
-               (locked = (tdb_brlock(tdb, ACTIVE_LOCK, F_WRLCK, F_SETLK, 0) == 0))) {
-               open_flags |= O_CREAT;
-               if (ftruncate(tdb->fd, 0) == -1) {
-                       TDB_LOG((tdb, 0, "tdb_open_ex: "
-                                "failed to truncate %s: %s\n",
-                                name, strerror(errno)));
-                       goto fail; /* errno set by ftruncate */
-               }
-       }
-
-       if (read(tdb->fd, &tdb->header, sizeof(tdb->header)) != sizeof(tdb->header)
-           || strcmp(tdb->header.magic_food, TDB_MAGIC_FOOD) != 0
-           || (tdb->header.version != TDB_VERSION
-               && !(rev = (tdb->header.version==TDB_BYTEREV(TDB_VERSION))))) {
-               /* its not a valid database - possibly initialise it */
-               if (!(open_flags & O_CREAT) || tdb_new_database(tdb, hash_size) == -1) {
-                       errno = EIO; /* ie bad format or something */
-                       goto fail;
-               }
-               rev = (tdb->flags & TDB_CONVERT);
-       }
-       vp = (unsigned char *)&tdb->header.version;
-       vertest = (((u32)vp[0]) << 24) | (((u32)vp[1]) << 16) |
-                 (((u32)vp[2]) << 8) | (u32)vp[3];
-       tdb->flags |= (vertest==TDB_VERSION) ? TDB_BIGENDIAN : 0;
-       if (!rev)
-               tdb->flags &= ~TDB_CONVERT;
-       else {
-               tdb->flags |= TDB_CONVERT;
-               convert(&tdb->header, sizeof(tdb->header));
-       }
-       if (fstat(tdb->fd, &st) == -1)
-               goto fail;
-
-       /* Is it already in the open list?  If so, fail. */
-       if (tdb_already_open(st.st_dev, st.st_ino)) {
-               TDB_LOG((tdb, 2, "tdb_open_ex: "
-                        "%s (%d,%d) is already open in this process\n",
-                        name, (int)st.st_dev, (int)st.st_ino));
-               errno = EBUSY;
-               goto fail;
-       }
-
-       if (!(tdb->name = (char *)strdup(name))) {
-               errno = ENOMEM;
-               goto fail;
-       }
-
-       tdb->map_size = st.st_size;
-       tdb->device = st.st_dev;
-       tdb->inode = st.st_ino;
-       tdb->locked = calloc(tdb->header.hash_size+1, sizeof(tdb->locked[0]));
-       if (!tdb->locked) {
-               TDB_LOG((tdb, 2, "tdb_open_ex: "
-                        "failed to allocate lock structure for %s\n",
-                        name));
-               errno = ENOMEM;
-               goto fail;
-       }
-       tdb_mmap(tdb);
-       if (locked) {
-               if (!tdb->read_only)
-                       if (tdb_clear_spinlocks(tdb) != 0) {
-                               TDB_LOG((tdb, 0, "tdb_open_ex: "
-                               "failed to clear spinlock\n"));
-                               goto fail;
-                       }
-               if (tdb_brlock(tdb, ACTIVE_LOCK, F_UNLCK, F_SETLK, 0) == -1) {
-                       TDB_LOG((tdb, 0, "tdb_open_ex: "
-                                "failed to take ACTIVE_LOCK on %s: %s\n",
-                                name, strerror(errno)));
-                       goto fail;
-               }
-
-       }
-
-       /* We always need to do this if the CLEAR_IF_FIRST flag is set, even if
-          we didn't get the initial exclusive lock as we need to let all other
-          users know we're using it. */
-
-       if (tdb_flags & TDB_CLEAR_IF_FIRST) {
-               /* leave this lock in place to indicate it's in use */
-               if (tdb_brlock(tdb, ACTIVE_LOCK, F_RDLCK, F_SETLKW, 0) == -1)
-                       goto fail;
-       }
-
-
- internal:
-       /* Internal (memory-only) databases skip all the code above to
-        * do with disk files, and resume here by releasing their
-        * global lock and hooking into the active list. */
-       if (tdb_brlock(tdb, GLOBAL_LOCK, F_UNLCK, F_SETLKW, 0) == -1)
-               goto fail;
-       tdb->next = tdbs;
-       tdbs = tdb;
-       return tdb;
-
- fail:
-       { int save_errno = errno;
-
-       if (!tdb)
-               return NULL;
-       
-       if (tdb->map_ptr) {
-               if (tdb->flags & TDB_INTERNAL)
-                       SAFE_FREE(tdb->map_ptr);
-               else
-                       tdb_munmap(tdb);
-       }
-       SAFE_FREE(tdb->name);
-       if (tdb->fd != -1)
-               if (close(tdb->fd) != 0)
-                       TDB_LOG((tdb, 5, "tdb_open_ex: failed to close tdb->fd on error!\n"));
-       SAFE_FREE(tdb->locked);
-       SAFE_FREE(tdb);
-       errno = save_errno;
-       return NULL;
-       }
-}
-
-/**
- * Close a database.
- *
- * @returns -1 for error; 0 for success.
- **/
-int tdb_close(TDB_CONTEXT *tdb)
-{
-       TDB_CONTEXT **i;
-       int ret = 0;
-
-       if (tdb->map_ptr) {
-               if (tdb->flags & TDB_INTERNAL)
-                       SAFE_FREE(tdb->map_ptr);
-               else
-                       tdb_munmap(tdb);
-       }
-       SAFE_FREE(tdb->name);
-       if (tdb->fd != -1)
-               ret = close(tdb->fd);
-       SAFE_FREE(tdb->locked);
-
-       /* Remove from contexts list */
-       for (i = &tdbs; *i; i = &(*i)->next) {
-               if (*i == tdb) {
-                       *i = tdb->next;
-                       break;
-               }
-       }
-
-       memset(tdb, 0, sizeof(*tdb));
-       SAFE_FREE(tdb);
-
-       return ret;
-}
-
-/* lock/unlock entire database */
-int tdb_lockall(TDB_CONTEXT *tdb)
-{
-       u32 i;
-
-       /* There are no locks on read-only dbs */
-       if (tdb->read_only)
-               return TDB_ERRCODE(TDB_ERR_LOCK, -1);
-       for (i = 0; i < tdb->header.hash_size; i++) 
-               if (tdb_lock(tdb, i, F_WRLCK))
-                       break;
-
-       /* If error, release locks we have... */
-       if (i < tdb->header.hash_size) {
-               u32 j;
-
-               for ( j = 0; j < i; j++)
-                       tdb_unlock(tdb, j, F_WRLCK);
-               return TDB_ERRCODE(TDB_ERR_NOLOCK, -1);
-       }
-
-       return 0;
-}
-void tdb_unlockall(TDB_CONTEXT *tdb)
-{
-       u32 i;
-       for (i=0; i < tdb->header.hash_size; i++)
-               tdb_unlock(tdb, i, F_WRLCK);
-}
-
-/* lock/unlock one hash chain. This is meant to be used to reduce
-   contention - it cannot guarantee how many records will be locked */
-int tdb_chainlock(TDB_CONTEXT *tdb, TDB_DATA key)
-{
-       return tdb_lock(tdb, BUCKET(tdb->hash_fn(&key)), F_WRLCK);
-}
-
-int tdb_chainunlock(TDB_CONTEXT *tdb, TDB_DATA key)
-{
-       return tdb_unlock(tdb, BUCKET(tdb->hash_fn(&key)), F_WRLCK);
-}
-
-int tdb_chainlock_read(TDB_CONTEXT *tdb, TDB_DATA key)
-{
-       return tdb_lock(tdb, BUCKET(tdb->hash_fn(&key)), F_RDLCK);
-}
-
-int tdb_chainunlock_read(TDB_CONTEXT *tdb, TDB_DATA key)
-{
-       return tdb_unlock(tdb, BUCKET(tdb->hash_fn(&key)), F_RDLCK);
-}
-
-
-/* register a loging function */
-void tdb_logging_function(TDB_CONTEXT *tdb, void (*fn)(TDB_CONTEXT *, int , const char *, ...))
-{
-       tdb->log_fn = fn;
-}
-
-/* reopen a tdb - this can be used after a fork to ensure that we have an independent
-   seek pointer from our parent and to re-establish locks */
-int tdb_reopen(TDB_CONTEXT *tdb)
-{
-       struct stat st;
-
-       if (tdb->flags & TDB_INTERNAL)
-               return 0; /* Nothing to do. */
-       if (tdb_munmap(tdb) != 0) {
-               TDB_LOG((tdb, 0, "tdb_reopen: munmap failed (%s)\n", strerror(errno)));
-               goto fail;
-       }
-       if (close(tdb->fd) != 0)
-               TDB_LOG((tdb, 0, "tdb_reopen: WARNING closing tdb->fd failed!\n"));
-       tdb->fd = open(tdb->name, tdb->open_flags & ~(O_CREAT|O_TRUNC), 0);
-       if (tdb->fd == -1) {
-               TDB_LOG((tdb, 0, "tdb_reopen: open failed (%s)\n", strerror(errno)));
-               goto fail;
-       }
-       if ((tdb->flags & TDB_CLEAR_IF_FIRST) &&
-                       (tdb_brlock(tdb, ACTIVE_LOCK, F_RDLCK, F_SETLKW, 0) == -1)) {
-               TDB_LOG((tdb, 0, "tdb_reopen: failed to obtain active lock\n"));
-               goto fail;
-       }
-       if (fstat(tdb->fd, &st) != 0) {
-               TDB_LOG((tdb, 0, "tdb_reopen: fstat failed (%s)\n", strerror(errno)));
-               goto fail;
-       }
-       if (st.st_ino != tdb->inode || st.st_dev != tdb->device) {
-               TDB_LOG((tdb, 0, "tdb_reopen: file dev/inode has changed!\n"));
-               goto fail;
-       }
-       tdb_mmap(tdb);
-
-       return 0;
-
-fail:
-       tdb_close(tdb);
-       return -1;
-}
-
-/* reopen all tdb's */
-int tdb_reopen_all(void)
-{
-       TDB_CONTEXT *tdb;
-
-       for (tdb=tdbs; tdb; tdb = tdb->next) {
-               if (tdb_reopen(tdb) != 0)
-                       return -1;
-       }
-
-       return 0;
-}
diff --git a/tdb/tdb.h b/tdb/tdb.h
deleted file mode 100644 (file)
index 5567d4a..0000000
--- a/tdb/tdb.h
+++ /dev/null
@@ -1,163 +0,0 @@
-/* $Id$ */
-/*-
- * Copyright (c) 1999-2004 Andrew Tridgell <tridge@linuxcare.com>
- * Copyright (c) 2005      Benedikt Meurer <benny@xfce.org>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library 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
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public
- * License along with this library; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
- *
- * This file was originally part of the tdb library, which in turn is
- * part of the Samba suite, a Unix SMB/CIFS implementation.
- */
-
-#ifndef __TDB_H__
-#define __TDB_H__
-
-#include <tdb/tdbconfig.h>
-
-#include <signal.h>
-#include <unistd.h>
-
-#ifdef  __cplusplus
-extern "C" {
-#endif
-
-#ifndef PRINTF_ATTRIBUTE
-/** Use gcc attribute to check printf fns.  a1 is the 1-based index of
- * the parameter containing the format, and a2 the index of the first
- * argument. Note that some gcc 2.x versions don't handle this
- * properly **/
-#if (__GNUC__ >= 3) && (__GNUC_MINOR__ >= 1 )
-#define PRINTF_ATTRIBUTE(a1, a2) __attribute__ ((format (__printf__, a1, a2)))
-#else
-#define PRINTF_ATTRIBUTE(a1, a2)
-#endif
-#endif
-
-/* flags to tdb_store() */
-#define TDB_REPLACE 1
-#define TDB_INSERT 2
-#define TDB_MODIFY 3
-
-/* flags for tdb_open() */
-#define TDB_DEFAULT 0 /* just a readability place holder */
-#define TDB_CLEAR_IF_FIRST 1
-#define TDB_INTERNAL 2 /* don't store on disk */
-#define TDB_NOLOCK   4 /* don't do any locking */
-#define TDB_NOMMAP   8 /* don't use mmap */
-#define TDB_CONVERT 16 /* convert endian (internal use) */
-#define TDB_BIGENDIAN 32 /* header is big-endian (internal use) */
-
-#define TDB_ERRCODE(code, ret) ((tdb->ecode = (code)), ret)
-
-/* error codes */
-enum TDB_ERROR {TDB_SUCCESS=0, TDB_ERR_CORRUPT, TDB_ERR_IO, TDB_ERR_LOCK, 
-               TDB_ERR_OOM, TDB_ERR_EXISTS, TDB_ERR_NOLOCK, TDB_ERR_LOCK_TIMEOUT,
-               TDB_ERR_NOEXIST};
-
-typedef struct {
-       char *dptr;
-       size_t dsize;
-} TDB_DATA;
-
-typedef u32 tdb_len;
-typedef u32 tdb_off;
-
-/* this is stored at the front of every database */
-struct tdb_header {
-       char magic_food[32]; /* for /etc/magic */
-       u32 version; /* version of the code */
-       u32 hash_size; /* number of hash entries */
-       tdb_off rwlocks;
-       tdb_off reserved[31];
-};
-
-struct tdb_lock_type {
-       u32 count;
-       u32 ltype;
-};
-
-struct tdb_traverse_lock {
-       struct tdb_traverse_lock *next;
-       u32 off;
-       u32 hash;
-};
-
-/* this is the context structure that is returned from a db open */
-typedef struct tdb_context {
-       char *name; /* the name of the database */
-       void *map_ptr; /* where it is currently mapped */
-       int fd; /* open file descriptor for the database */
-       tdb_len map_size; /* how much space has been mapped */
-       int read_only; /* opened read-only */
-       struct tdb_lock_type *locked; /* array of chain locks */
-       enum TDB_ERROR ecode; /* error code for last tdb error */
-       struct tdb_header header; /* a cached copy of the header */
-       u32 flags; /* the flags passed to tdb_open */
-       struct tdb_traverse_lock travlocks; /* current traversal locks */
-       struct tdb_context *next; /* all tdbs to avoid multiple opens */
-       dev_t device;   /* uniquely identifies this tdb */
-       ino_t inode;    /* uniquely identifies this tdb */
-       void (*log_fn)(struct tdb_context *tdb, int level, const char *, ...) PRINTF_ATTRIBUTE(3,4); /* logging function */
-       u32 (*hash_fn)(TDB_DATA *key);
-       int open_flags; /* flags used in the open - needed by reopen */
-} TDB_CONTEXT;
-
-typedef int (*tdb_traverse_func)(TDB_CONTEXT *, TDB_DATA, TDB_DATA, void *);
-typedef void (*tdb_log_func)(TDB_CONTEXT *, int , const char *, ...);
-typedef u32 (*tdb_hash_func)(TDB_DATA *key);
-
-TDB_CONTEXT *tdb_open(const char *name, int hash_size, int tdb_flags,
-                     int open_flags, mode_t mode);
-TDB_CONTEXT *tdb_open_ex(const char *name, int hash_size, int tdb_flags,
-                        int open_flags, mode_t mode,
-                        tdb_log_func log_fn,
-                        tdb_hash_func hash_fn);
-
-int tdb_reopen(TDB_CONTEXT *tdb);
-int tdb_reopen_all(void);
-void tdb_logging_function(TDB_CONTEXT *tdb, tdb_log_func);
-enum TDB_ERROR tdb_error(TDB_CONTEXT *tdb);
-const char *tdb_errorstr(TDB_CONTEXT *tdb);
-TDB_DATA tdb_fetch(TDB_CONTEXT *tdb, TDB_DATA key);
-int tdb_delete(TDB_CONTEXT *tdb, TDB_DATA key);
-int tdb_store(TDB_CONTEXT *tdb, TDB_DATA key, TDB_DATA dbuf, int flag);
-int tdb_append(TDB_CONTEXT *tdb, TDB_DATA key, TDB_DATA new_dbuf);
-int tdb_close(TDB_CONTEXT *tdb);
-TDB_DATA tdb_firstkey(TDB_CONTEXT *tdb);
-TDB_DATA tdb_nextkey(TDB_CONTEXT *tdb, TDB_DATA key);
-int tdb_traverse(TDB_CONTEXT *tdb, tdb_traverse_func fn, void *);
-int tdb_exists(TDB_CONTEXT *tdb, TDB_DATA key);
-int tdb_lockall(TDB_CONTEXT *tdb);
-void tdb_unlockall(TDB_CONTEXT *tdb);
-
-/* Low level locking functions: use with care */
-void tdb_set_lock_alarm(sig_atomic_t *palarm);
-int tdb_chainlock(TDB_CONTEXT *tdb, TDB_DATA key);
-int tdb_chainunlock(TDB_CONTEXT *tdb, TDB_DATA key);
-int tdb_chainlock_read(TDB_CONTEXT *tdb, TDB_DATA key);
-int tdb_chainunlock_read(TDB_CONTEXT *tdb, TDB_DATA key);
-
-/* Debug functions. Not used in production. */
-void tdb_dump_all(TDB_CONTEXT *tdb);
-int tdb_printfreelist(TDB_CONTEXT *tdb);
-
-extern TDB_DATA tdb_null;
-
-#ifdef  __cplusplus
-}
-#endif
-
-#endif /* !__TDB_H__ */
diff --git a/tdb/tdbconfig.h.in b/tdb/tdbconfig.h.in
deleted file mode 100644 (file)
index 91fcccd..0000000
+++ /dev/null
@@ -1,34 +0,0 @@
-/* $Id: tdbconfig.h.in 131 2005-11-04 15:15:34Z benny $ */
-/*-
- * Copyright (c) 2005 Benedikt Meurer <benny@xfce.org>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library 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
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public
- * License along with this library; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
- */
-
-#ifndef __TDBCONFIG_H__
-#define __TDBCONFIG_H__
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef @TDB_U32_TYPE@ u32;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* !__TDBCONFIG_H__ */
diff --git a/tdb/tdbspeed.c b/tdb/tdbspeed.c
deleted file mode 100644 (file)
index f5e5255..0000000
+++ /dev/null
@@ -1,208 +0,0 @@
-/* $Id$ */
-/*-
- * Copyright (c) 1999-2004 Andrew Tridgell <tridge@linuxcare.com>
- * Copyright (c) 2005      Benedikt Meurer <benny@xfce.org>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library 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
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public
- * License along with this library; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
- *
- * This file was originally part of the tdb library, which in turn is
- * part of the Samba suite, a Unix SMB/CIFS implementation.
- */
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#ifdef HAVE_SYS_TYPES_H
-#include <sys/types.h>
-#endif
-#ifdef HAVE_SYS_MMAN_H
-#include <sys/mman.h>
-#endif
-#ifdef HAVE_SYS_STAT_H
-#include <sys/stat.h>
-#endif
-#ifdef HAVE_SYS_TIME_H
-#include <sys/time.h>
-#endif
-
-#ifdef HAVE_STDLIB_H
-#include <stdlib.h>
-#endif
-#include <stdio.h>
-#ifdef HAVE_FCNTL_H
-#include <fcntl.h>
-#endif
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#ifdef HAVE_STRING_H
-#include <string.h>
-#endif
-#ifdef HAVE_MEMORY_H
-#include <memory.h>
-#endif
-
-#include <tdb/tdb.h>
-
-/* Turn off if error returns from TDB are sane (before v1.0.2) */
-#if 1
-#define TDB_ERROR(tdb, code) ((tdb)->ecode == code)
-#else
-#define TDB_ERROR(tdb, code) 1
-#endif
-/* a test program for tdb - the trivial database */
-
-static TDB_DATA *randdata, *randkeys;
-
-#define DELETE_PROB 7
-#define STORE_PROB 5
-
-static TDB_CONTEXT *db;
-
-struct timeval tp1,tp2;
-
-static void start_timer(void)
-{
-       gettimeofday(&tp1,NULL);
-}
-
-static double end_timer(void)
-{
-       gettimeofday(&tp2,NULL);
-       return((tp2.tv_sec - tp1.tv_sec) + 
-              (tp2.tv_usec - tp1.tv_usec)*1.0e-6);
-}
-
-static void fatal(TDB_CONTEXT *tdb, const char *why)
-{
-       perror(why);
-       if (tdb) fprintf(stderr, "TDB: (%u)\n", tdb->ecode);
-       exit(1);
-}
-
-static char *randbuf(int len)
-{
-       char *buf;
-       int i;
-       buf = (char *)malloc(len+1);
-
-       for (i=0;i<len;i++) {
-               buf[i] = 'a' + (rand() % 26);
-       }
-       buf[i] = 0;
-       return buf;
-}
-
-static void addrec_db(int i)
-{
-       TDB_DATA key, data;
-
-       key.dptr = randkeys[i].dptr;
-       key.dsize = randkeys[i].dsize+1;
-
-       data.dptr = randdata[i].dptr;
-       data.dsize = randdata[i].dsize+1;
-
-       if (rand() % DELETE_PROB == 0) {
-               if (tdb_delete(db, key) == -1
-                   && !TDB_ERROR(db, TDB_ERR_NOEXIST))
-                       fatal(db, "tdb_delete failed");
-       } else if (rand() % STORE_PROB == 0) {
-               if (tdb_store(db, key, data, TDB_REPLACE) != 0) {
-                       fatal(db, "tdb_store failed");
-               }
-       } else {
-               data = tdb_fetch(db, key);
-               if (data.dptr) free(data.dptr);
-               else {
-                       if (db->ecode && !TDB_ERROR(db,TDB_ERR_NOEXIST))
-                               fatal(db, "tdb_fetch failed");
-               }
-       }
-}
-
-struct db_size {
-       const char *name;
-       int size;
-} db_sizes[]
-= { { "default", 0 },
-    { "307", 307 },
-    { "512", 512 },
-    { "1024", 1024 },
-    { "4096", 4096 },
-    { "16384", 16384 },
-    { "65536", 65536 } };
-
-unsigned int num_loops[]  /* 10,000 each */
-= { 1, 5, 25 };
-
-struct tdb_flag {
-       const char *name;
-       int flags;
-} tdb_flags[]
-= { { "normal", TDB_CLEAR_IF_FIRST },
-#ifdef TDB_CONVERT
-    { "byte-reversed", TDB_CLEAR_IF_FIRST|TDB_CONVERT }
-#endif
-};
-
-int main(int argc, char *argv[])
-{
-       int seed=0;
-       unsigned int i, k, j;
-
-       /* Precook random buffers */
-       randdata = malloc(10000 * sizeof(randdata[0]));
-       randkeys = malloc(10000 * sizeof(randkeys[0]));
-
-       srand(seed);
-       for (i=0;i<10000;i++) {
-               randkeys[i].dsize = 1 + (rand() % 4);
-               randdata[i].dsize = 1 + (rand() % 100);
-               randkeys[i].dptr = randbuf(randkeys[i].dsize);
-               randdata[i].dptr = randbuf(randdata[i].dsize);
-       }
-
-       for (k = 0; k < sizeof(tdb_flags)/sizeof(struct tdb_flag); k++) {
-               printf("Operations per second for %s database:\n",
-                      tdb_flags[k].name);
-
-               printf("Hashsize:   ");
-               for (i = 0; i < sizeof(db_sizes)/sizeof(struct db_size); i++)
-                       printf("%-8s ", db_sizes[i].name);
-               printf("\n");
-               
-               for (i = 0; i < sizeof(num_loops)/sizeof(int); i++) {
-                       printf("%7u:    ", num_loops[i]*10000);
-                       for (j = 0; j < sizeof(db_sizes)/sizeof(struct db_size); j++) {
-                               unsigned int l = 0, l2;
-                               db = tdb_open("test.tdb", db_sizes[j].size,
-                                             tdb_flags[k].flags,
-                                             O_RDWR | O_CREAT | O_TRUNC, 0600);
-                               srand(seed);
-                               start_timer();
-                               for (l2=0; l2 < num_loops[i]; l2++)
-                                       for (l=0;l<10000;l++) addrec_db(l);
-                               printf("%-7u  ", (int)(l*l2/end_timer()));
-                               tdb_close(db);
-                       }
-                       printf("\n");
-               }
-               printf("\n");
-       }
-       return 0;
-}
diff --git a/tdb/tdbtool.c b/tdb/tdbtool.c
deleted file mode 100644 (file)
index 5da5066..0000000
+++ /dev/null
@@ -1,521 +0,0 @@
-/* $Id$ */
-/*-
- * Copyright (c) 1999-2000 Andrew Tridgell
- * Copyright (c) 2000      Paul `Rusty' Russell
- * Copyright (c) 2000      Jeremy Allison
- * Copyright (c) 2001      Andrew Esh
- * Copyright (c) 2005      Benedikt Meurer <benny@xfce.org>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library 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
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public
- * License along with this library; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
- *
- * This file was originally part of the tdb library, which in turn is
- * part of the Samba suite, a Unix SMB/CIFS implementation.
- */
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#ifdef HAVE_SYS_TYPES_H
-#include <sys/types.h>
-#endif
-#ifdef HAVE_SYS_MMAN_H
-#include <sys/mman.h>
-#endif
-#ifdef HAVE_SYS_STAT_H
-#include <sys/stat.h>
-#endif
-#ifdef HAVE_SYS_TIME_H
-#include <sys/time.h>
-#endif
-
-#ifdef HAVE_CTYPE_H
-#include <ctype.h>
-#endif
-#ifdef HAVE_ERRNO_H
-#include <errno.h>
-#endif
-#ifdef HAVE_FCNTL_H
-#include <fcntl.h>
-#endif
-#ifdef HAVE_MEMORY_H
-#include <memory.h>
-#endif
-#ifdef HAVE_STDLIB_H
-#include <stdlib.h>
-#endif
-#include <stdio.h>
-#ifdef HAVE_STRING_H
-#include <string.h>
-#endif
-#ifdef HAVE_TIME_H
-#include <time.h>
-#endif
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-
-#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ > 4)
-#define G_GNUC_UNUSED __attribute__((__unused__))
-#else
-#define G_GNUC_UNUSED
-#endif
-
-#include <tdb/tdb.h>
-
-/* a tdb tool for manipulating a tdb database */
-
-#define FSTRING_LEN 256
-typedef char fstring[FSTRING_LEN];
-
-typedef struct connections_key {
-  pid_t pid;
-  int cnum;
-  fstring name;
-} connections_key;
-
-typedef struct connections_data {
-  int magic;
-  pid_t pid;
-  int cnum;
-  uid_t uid;
-  gid_t gid;
-  char name[24];
-  char addr[24];
-  char machine[128];
-  time_t start;
-} connections_data;
-
-static TDB_CONTEXT *tdb;
-FILE *pDumpFile;
-
-static int print_rec(TDB_CONTEXT *tdb, TDB_DATA key, TDB_DATA dbuf, void *state);
-
-static char *get_token(int startover)
-{
-  static char tmp[1024];
-  static char *cont = NULL;
-  char *insert, *start;
-  char *k = strtok(NULL, " ");
-
-  if (!k)
-    return NULL;
-
-  if (startover)
-    start = tmp;
-  else
-    start = cont;
-
-  strcpy(start, k);
-  insert = start + strlen(start) - 1;
-  while (*insert == '\\') {
-    *insert++ = ' ';
-    k = strtok(NULL, " ");
-    if (!k)
-      break;
-    strcpy(insert, k);
-    insert = start + strlen(start) - 1;
-  }
-
-  /* Get ready for next call */
-  cont = start + strlen(start) + 1;
-  return start;
-}
-
-static int open_dump_file(void)
-{
-  int retval = 0;
-  char *tok = get_token(0);
-  if (!tok) {
-    pDumpFile = stdout;
-  } else {
-    pDumpFile = fopen(tok, "w");
-    
-    if (pDumpFile == NULL) {
-      printf("File Open Failed! --  %s", tok);
-      retval = 1;
-    } else {
-      printf("Writing to file: %s\n", tok);
-    }
-  }
-    return(retval);
-}
-
-static void close_dump_file(void)
-{
-  if(pDumpFile != NULL && pDumpFile != stdout) {
-    fclose(pDumpFile);
-  }
-}
-
- static void print_asc(unsigned char *buf,int len)
-{
-  int i;
-
-  /* We're probably printing ASCII strings so don't try to display
-     the trailing NULL character. */
-
-  if (buf[len - 1] == 0)
-          len--;
-
-  for (i=0;i<len;i++)
-    fprintf(pDumpFile,"%c",isprint(buf[i])?buf[i]:'.');
-}
-
-static void print_data(unsigned char *buf,int len)
-{
-  int i=0;
-  if (len<=0) return;
-  fprintf(pDumpFile,"[%03X] ",i);
-  for (i=0;i<len;) {
-    fprintf(pDumpFile,"%02X ",(int)buf[i]);
-    i++;
-    if (i%8 == 0) fprintf(pDumpFile," ");
-    if (i%16 == 0) {      
-      print_asc(&buf[i-16],8); fprintf(pDumpFile," ");
-      print_asc(&buf[i-8],8); fprintf(pDumpFile,"\n");
-      if (i<len) fprintf(pDumpFile,"[%03X] ",i);
-    }
-  }
-  if (i%16) {
-    int n;
-    
-    n = 16 - (i%16);
-    fprintf(pDumpFile," ");
-    if (n>8) fprintf(pDumpFile," ");
-    while (n--) fprintf(pDumpFile,"   ");
-    
-    n = i%16;
-    if (n > 8) n = 8;
-    print_asc(&buf[i-(i%16)],n); fprintf(pDumpFile," ");
-    n = (i%16) - n;
-    if (n>0) print_asc(&buf[i-n],n); 
-    fprintf(pDumpFile,"\n");    
-  }
-}
-
-static void help(void)
-{
-  printf(
-"tdbtool:\n"
-"  create    dbname     : create a database\n"
-"  open      dbname     : open an existing database\n"
-"  erase                : erase the database\n"
-"  dump      dumpname   : dump the database as strings\n"
-"  insert    key  data  : insert a record\n"
-"  store     key  data  : store a record (replace)\n"
-"  show      key        : show a record by key\n"
-"  delete    key        : delete a record by key\n"
-"  list                 : print the database hash table and freelist\n"
-"  free                 : print the database freelist\n"
-"  1 | first            : print the first record\n"
-"  n | next             : print the next record\n"
-"  q | quit             : terminate\n"
-"  \\n                   : repeat 'next' command\n");
-}
-
-static void terror(char *why)
-{
-  printf("%s\n", why);
-}
-
-static void create_tdb(void)
-{
-  char *tok = get_token(1);
-  if (!tok) {
-    help();
-    return;
-  }
-  if (tdb) tdb_close(tdb);
-  tdb = tdb_open(tok, 0, TDB_CLEAR_IF_FIRST,
-           O_RDWR | O_CREAT | O_TRUNC, 0600);
-  if (!tdb) {
-    printf("Could not create %s: %s\n", tok, strerror(errno));
-  }
-}
-
-static void open_tdb(void)
-{
-  char *tok = get_token(1);
-  if (!tok) {
-    help();
-    return;
-  }
-  if (tdb) tdb_close(tdb);
-  tdb = tdb_open(tok, 0, 0, O_RDWR, 0600);
-  if (!tdb) {
-    printf("Could not open %s: %s\n", tok, strerror(errno));
-  }
-}
-
-static void insert_tdb(void)
-{
-  char *k = get_token(1);
-  char *d = get_token(0);
-  TDB_DATA key, dbuf;
-
-  if (!k || !d) {
-    help();
-    return;
-  }
-
-  key.dptr = k;
-  key.dsize = strlen(k)+1;
-  dbuf.dptr = d;
-  dbuf.dsize = strlen(d)+1;
-
-  if (tdb_store(tdb, key, dbuf, TDB_INSERT) == -1) {
-    terror("insert failed");
-  }
-}
-
-static void store_tdb(void)
-{
-  char *k = get_token(1);
-  char *d = get_token(0);
-  TDB_DATA key, dbuf;
-
-  if (!k || !d) {
-    help();
-    return;
-  }
-
-  key.dptr = k;
-  key.dsize = strlen(k)+1;
-  dbuf.dptr = d;
-  dbuf.dsize = strlen(d)+1;
-
-  printf("Storing key:\n");
-  print_rec(tdb, key, dbuf, NULL);
-
-  if (tdb_store(tdb, key, dbuf, TDB_REPLACE) == -1) {
-    terror("store failed");
-  }
-}
-
-static void show_tdb(void)
-{
-  char *k = get_token(1);
-  TDB_DATA key, dbuf;
-
-  if (!k) {
-    help();
-    return;
-  }
-
-  key.dptr = k;
-  key.dsize = strlen(k)+1;
-
-  dbuf = tdb_fetch(tdb, key);
-  if (!dbuf.dptr) {
-    terror("fetch failed");
-    return;
-  }
-  /* printf("%s : %*.*s\n", k, (int)dbuf.dsize, (int)dbuf.dsize, dbuf.dptr); */
-  print_rec(tdb, key, dbuf, NULL);
-}
-
-static void delete_tdb(void)
-{
-  char *k = get_token(1);
-  TDB_DATA key;
-
-  if (!k) {
-    help();
-    return;
-  }
-
-  key.dptr = k;
-  key.dsize = strlen(k)+1;
-
-  if (tdb_delete(tdb, key) != 0) {
-    terror("delete failed");
-  }
-}
-
-static int print_rec(TDB_CONTEXT *context, TDB_DATA key, TDB_DATA dbuf, void *state)
-{
-  fprintf(pDumpFile,"\nkey %u bytes\n", (unsigned) key.dsize);
-  print_asc((unsigned char*)key.dptr, key.dsize);
-  fprintf(pDumpFile,"\ndata %u bytes\n", (unsigned) dbuf.dsize);
-  print_data((unsigned char*)dbuf.dptr, dbuf.dsize);
-  return 0;
-}
-
-static int print_key(TDB_CONTEXT *context, TDB_DATA key, TDB_DATA dbuf, void *state)
-{
-  print_asc((unsigned char*)key.dptr, key.dsize);
-  printf("\n");
-  return 0;
-}
-
-static int total_bytes;
-
-static int traverse_fn(TDB_CONTEXT *context, TDB_DATA key, TDB_DATA dbuf, void *state)
-{
-  total_bytes += dbuf.dsize;
-  return 0;
-}
-
-static void info_tdb(void)
-{
-  int count;
-  total_bytes = 0;
-  if ((count = tdb_traverse(tdb, traverse_fn, NULL) == -1))
-    printf("Error = %s\n", tdb_errorstr(tdb));
-  else
-    printf("%d records totalling %d bytes\n", count, total_bytes);
-}
-
-static char *tdb_getline(char *prompt)
-{
-  static char line[1024];
-  char *p;
-  fputs(prompt, stdout);
-  line[0] = 0;
-  p = fgets(line, sizeof(line)-1, stdin);
-  if (p) p = strchr(p, '\n');
-  if (p) *p = 0;
-  pDumpFile = stdout;
-  return p?line:NULL;
-}
-
-static int do_delete_fn(TDB_CONTEXT *context, TDB_DATA key, TDB_DATA dbuf,
-                     void *state)
-{
-    return tdb_delete(context, key);
-}
-
-static void first_record(TDB_CONTEXT *context, TDB_DATA *pkey)
-{
-  TDB_DATA dbuf;
-  *pkey = tdb_firstkey(context);
-  
-  dbuf = tdb_fetch(context, *pkey);
-  if (!dbuf.dptr) terror("fetch failed");
-  /* printf("%s : %*.*s\n", k, (int)dbuf.dsize, (int)dbuf.dsize, dbuf.dptr); */
-  print_rec(context, *pkey, dbuf, NULL);
-}
-
-static void next_record(TDB_CONTEXT *context, TDB_DATA *pkey)
-{
-  TDB_DATA dbuf;
-  *pkey = tdb_nextkey(context, *pkey);
-  
-  dbuf = tdb_fetch(context, *pkey);
-  if (!dbuf.dptr) 
-    terror("fetch failed");
-  else
-    /* printf("%s : %*.*s\n", k, (int)dbuf.dsize, (int)dbuf.dsize, dbuf.dptr); */
-    print_rec(context, *pkey, dbuf, NULL);
-}
-
-int main(int argc, char *argv[])
-{
-    int bIterate = 0;
-    int ignore G_GNUC_UNUSED;
-    char *line;
-    char *tok;
-  TDB_DATA iterate_kbuf;
-
-    if (argv[1]) {
-  static char tmp[1024];
-        sprintf(tmp, "open %s", argv[1]);
-        tok=strtok(tmp," ");
-        open_tdb();
-    }
-
-    while ((line = tdb_getline("tdb> "))) {
-
-        /* Shell command */
-        
-        if (line[0] == '!') {
-            ignore = system(line + 1);
-            continue;
-        }
-        
-        if ((tok = strtok(line," "))==NULL) {
-           if (bIterate)
-              next_record(tdb, &iterate_kbuf);
-           continue;
-        }
-        if (strcmp(tok,"create") == 0) {
-            bIterate = 0;
-            create_tdb();
-            continue;
-        } else if (strcmp(tok,"open") == 0) {
-            open_tdb();
-            continue;
-        } else if ((strcmp(tok, "q") == 0) ||
-                   (strcmp(tok, "quit") == 0)) {
-            break;
-  }
-            
-        /* all the rest require a open database */
-        if (!tdb) {
-            bIterate = 0;
-            terror("database not open");
-            help();
-            continue;
-        }
-            
-        if (strcmp(tok,"insert") == 0) {
-            bIterate = 0;
-            insert_tdb();
-        } else if (strcmp(tok,"store") == 0) {
-            bIterate = 0;
-            store_tdb();
-        } else if (strcmp(tok,"show") == 0) {
-            bIterate = 0;
-            show_tdb();
-        } else if (strcmp(tok,"erase") == 0) {
-            bIterate = 0;
-            tdb_traverse(tdb, do_delete_fn, NULL);
-        } else if (strcmp(tok,"delete") == 0) {
-            bIterate = 0;
-            delete_tdb();
-        } else if (strcmp(tok,"dump") == 0) {
-            bIterate = 0;
-      if(open_dump_file() == 0) { /* open file */
-        tdb_traverse(tdb, print_rec, NULL);
-        close_dump_file(); /* close file */
-      }
-      pDumpFile = stdout;
-        } else if (strcmp(tok,"list") == 0) {
-            tdb_dump_all(tdb);
-        } else if (strcmp(tok, "free") == 0) {
-            tdb_printfreelist(tdb);
-        } else if (strcmp(tok,"info") == 0) {
-            info_tdb();
-        } else if ( (strcmp(tok, "1") == 0) ||
-                    (strcmp(tok, "first") == 0)) {
-            bIterate = 1;
-            first_record(tdb, &iterate_kbuf);
-        } else if ((strcmp(tok, "n") == 0) ||
-                   (strcmp(tok, "next") == 0)) {
-            next_record(tdb, &iterate_kbuf);
-        } else if ((strcmp(tok, "keys") == 0)) {
-                bIterate = 0;
-                tdb_traverse(tdb, print_key, NULL);
-        } else {
-            help();
-        }
-    }
-
-    if (tdb) tdb_close(tdb);
-
-    return 0;
-}
diff --git a/tdb/tdbtorture.c b/tdb/tdbtorture.c
deleted file mode 100644 (file)
index c2fe916..0000000
+++ /dev/null
@@ -1,278 +0,0 @@
-/* $Id$ */
-/*-
- * Copyright (c) 1999-2004 Andrew Tridgell <tridge@linuxcare.com>
- * Copyright (c) 2005      Benedikt Meurer <benny@xfce.org>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library 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
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public
- * License along with this library; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
- *
- * This file was originally part of the tdb library, which in turn is
- * part of the Samba suite, a Unix SMB/CIFS implementation.
- */
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#ifdef HAVE_SYS_TYPES_H
-#include <sys/types.h>
-#endif
-#ifdef HAVE_SYS_MMAN_h
-#include <sys/mman.h>
-#endif
-#ifdef HAVE_SYS_STAT_H
-#include <sys/stat.h>
-#endif
-#ifdef HAVE_SYS_TIME_H
-#include <sys/time.h>
-#endif
-#ifdef HAVE_SYS_WAIT_H
-#include <sys/wait.h>
-#endif
-
-#ifdef HAVE_FCNTL_H
-#include <fcntl.h>
-#endif
-#ifdef HAVE_STDARG_H
-#include <stdarg.h>
-#endif
-#include <stdio.h>
-#ifdef HAVE_STDLIB_H
-#include <stdlib.h>
-#endif
-#ifdef HAVE_STRING_H
-#include <string.h>
-#endif
-#ifdef HAVE_TIME_H
-#include <time.h>
-#endif
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-
-#include <tdb/tdb.h>
-
-/* this tests tdb by doing lots of ops from several simultaneous
-   writers - that stresses the locking code. Build with TDB_DEBUG=1
-   for best effect */
-
-
-
-#define REOPEN_PROB 30
-#define DELETE_PROB 8
-#define STORE_PROB 4
-#define APPEND_PROB 6
-#define LOCKSTORE_PROB 0
-#define TRAVERSE_PROB 20
-#define CULL_PROB 100
-#define KEYLEN 3
-#define DATALEN 100
-#define LOCKLEN 20
-
-static TDB_CONTEXT *db;
-
-static void tdb_log(TDB_CONTEXT *tdb, int level, const char *format, ...)
-{
-       va_list ap;
-    
-       va_start(ap, format);
-       vfprintf(stdout, format, ap);
-       va_end(ap);
-       fflush(stdout);
-#if 0
-       {
-               char *ptr;
-               asprintf(&ptr,"xterm -e gdb /proc/%d/exe %d", getpid(), getpid());
-               system(ptr);
-               free(ptr);
-       }
-#endif 
-}
-
-static void fatal(char *why)
-{
-       perror(why);
-       exit(1);
-}
-
-static char *randbuf(int len)
-{
-       char *buf;
-       int i;
-       buf = (char *)malloc(len+1);
-
-       for (i=0;i<len;i++) {
-               buf[i] = 'a' + (rand() % 26);
-       }
-       buf[i] = 0;
-       return buf;
-}
-
-static int cull_traverse(TDB_CONTEXT *tdb, TDB_DATA key, TDB_DATA dbuf,
-                        void *state)
-{
-       if (random() % CULL_PROB == 0) {
-               tdb_delete(tdb, key);
-       }
-       return 0;
-}
-
-static void addrec_db(void)
-{
-       int klen, dlen, slen;
-       char *k, *d, *s;
-       TDB_DATA key, data, lockkey;
-
-       klen = 1 + (rand() % KEYLEN);
-       dlen = 1 + (rand() % DATALEN);
-       slen = 1 + (rand() % LOCKLEN);
-
-       k = randbuf(klen);
-       d = randbuf(dlen);
-       s = randbuf(slen);
-
-       key.dptr = k;
-       key.dsize = klen+1;
-
-       data.dptr = d;
-       data.dsize = dlen+1;
-
-       lockkey.dptr = s;
-       lockkey.dsize = slen+1;
-
-#if REOPEN_PROB
-       if (random() % REOPEN_PROB == 0) {
-               tdb_reopen_all();
-               goto next;
-       } 
-#endif
-
-#if DELETE_PROB
-       if (random() % DELETE_PROB == 0) {
-               tdb_delete(db, key);
-               goto next;
-       }
-#endif
-
-#if STORE_PROB
-       if (random() % STORE_PROB == 0) {
-               if (tdb_store(db, key, data, TDB_REPLACE) != 0) {
-                       fatal("tdb_store failed");
-               }
-               goto next;
-       }
-#endif
-
-#if APPEND_PROB
-       if (random() % APPEND_PROB == 0) {
-               if (tdb_append(db, key, data) != 0) {
-                       fatal("tdb_append failed");
-               }
-               goto next;
-       }
-#endif
-
-#if LOCKSTORE_PROB
-       if (random() % LOCKSTORE_PROB == 0) {
-               tdb_chainlock(db, lockkey);
-               data = tdb_fetch(db, key);
-               if (tdb_store(db, key, data, TDB_REPLACE) != 0) {
-                       fatal("tdb_store failed");
-               }
-               if (data.dptr) free(data.dptr);
-               tdb_chainunlock(db, lockkey);
-               goto next;
-       } 
-#endif
-
-#if TRAVERSE_PROB
-       if (random() % TRAVERSE_PROB == 0) {
-               tdb_traverse(db, cull_traverse, NULL);
-               goto next;
-       }
-#endif
-
-       data = tdb_fetch(db, key);
-       if (data.dptr) free(data.dptr);
-
-next:
-       free(k);
-       free(d);
-       free(s);
-}
-
-static int traverse_fn(TDB_CONTEXT *tdb, TDB_DATA key, TDB_DATA dbuf,
-                       void *state)
-{
-       tdb_delete(tdb, key);
-       return 0;
-}
-
-#ifndef NPROC
-#define NPROC 6
-#endif
-
-#ifndef NLOOPS
-#define NLOOPS 200000
-#endif
-
-int main(int argc, char *argv[])
-{
-       int i, seed=0;
-       int loops = NLOOPS;
-       pid_t pids[NPROC];
-
-       pids[0] = getpid();
-
-       for (i=0;i<NPROC-1;i++) {
-               if ((pids[i+1]=fork()) == 0) break;
-       }
-
-       db = tdb_open("torture.tdb", 2, TDB_CLEAR_IF_FIRST, 
-                     O_RDWR | O_CREAT, 0600);
-       if (!db) {
-               fatal("db open failed");
-       }
-       tdb_logging_function(db, tdb_log);
-
-       srand(seed + getpid());
-       srandom(seed + getpid() + time(NULL));
-       for (i=0;i<loops;i++) addrec_db();
-
-       tdb_traverse(db, NULL, NULL);
-       tdb_traverse(db, traverse_fn, NULL);
-       tdb_traverse(db, traverse_fn, NULL);
-
-       tdb_close(db);
-
-       if (getpid() == pids[0]) {
-               for (i=0;i<NPROC-1;i++) {
-                       int status;
-                       if (waitpid(pids[i+1], &status, 0) != pids[i+1]) {
-                               printf("failed to wait for %d\n",
-                                      (int)pids[i+1]);
-                               exit(1);
-                       }
-                       if (WEXITSTATUS(status) != 0) {
-                               printf("child %d exited with status %d\n",
-                                      (int)pids[i+1], WEXITSTATUS(status));
-                               exit(1);
-                       }
-               }
-               printf("OK\n");
-       }
-
-       return 0;
-}
index 4065d87..087c9cc 100644 (file)
@@ -133,8 +133,6 @@ thunar_SOURCES =                                                    \
        thunar-location-dialog.h                                        \
        thunar-location-entry.c                                         \
        thunar-location-entry.h                                         \
-       thunar-metafile.c                                               \
-       thunar-metafile.h                                               \
        thunar-misc-jobs.c                                              \
        thunar-misc-jobs.h                                              \
        thunar-navigator.c                                              \
@@ -238,7 +236,6 @@ thunar_LDFLAGS =                                                    \
        $(PLATFORM_LDFLAGS)
 
 thunar_LDADD =                                                         \
-       $(top_builddir)/tdb/libtdb.la                                   \
        $(top_builddir)/thunarx/libthunarx-$(THUNARX_VERSION_API).la    \
        $(EXO_LIBS)                                                     \
        $(GIO_LIBS)                                                     \
@@ -250,7 +247,6 @@ thunar_LDADD =                                                              \
        $(LIBXFCE4UI_LIBS)
 
 thunar_DEPENDENCIES =                                                  \
-       $(top_builddir)/tdb/libtdb.la                                   \
        $(top_builddir)/thunarx/libthunarx-$(THUNARX_VERSION_API).la
 
 if HAVE_DBUS
index 90571a5..45057e6 100644 (file)
@@ -69,9 +69,7 @@
 
 
 /* Additional flags associated with a ThunarFile */
-#define THUNAR_FILE_IN_DESTRUCTION          0x04
-#define THUNAR_FILE_OWNS_METAFILE_REFERENCE 0x08
-#define THUNAR_FILE_OWNS_EMBLEM_NAMES       0x10
+#define THUNAR_FILE_IN_DESTRUCTION 0x04
 
 
 /* the watch count is stored in the GObject data
@@ -111,7 +109,6 @@ static gboolean           thunar_file_denies_access_permission (const ThunarFile
                                                                 ThunarFileMode          usr_permissions,
                                                                 ThunarFileMode          grp_permissions,
                                                                 ThunarFileMode          oth_permissions);
-static ThunarMetafile    *thunar_file_get_metafile             (ThunarFile             *file);
 static void               thunar_file_monitor                  (GFileMonitor           *monitor,
                                                                 GFile                  *path,
                                                                 GFile                  *other_path,
@@ -125,12 +122,10 @@ G_LOCK_DEFINE_STATIC (file_cache_mutex);
 
 
 static ThunarUserManager *user_manager;
-static ThunarMetafile    *metafile;
 static GHashTable        *file_cache;
 static guint32            effective_user_id;
 static GQuark             thunar_file_thumb_path_quark;
 static GQuark             thunar_file_watch_count_quark;
-static GQuark             thunar_file_emblem_names_quark;
 static guint              file_signals[LAST_SIGNAL];
 
 
@@ -199,7 +194,6 @@ thunar_file_class_init (ThunarFileClass *klass)
   /* pre-allocate the required quarks */
   thunar_file_thumb_path_quark = g_quark_from_static_string ("thunar-file-thumb-path");
   thunar_file_watch_count_quark = g_quark_from_static_string ("thunar-file-watch-count");
-  thunar_file_emblem_names_quark = g_quark_from_static_string ("thunar-file-emblem-names");
 
   /* grab a reference on the user manager */
   user_manager = thunar_user_manager_get_default ();
@@ -293,10 +287,6 @@ thunar_file_finalize (GObject *object)
   g_hash_table_remove (file_cache, file->gfile);
   G_UNLOCK (file_cache_mutex);
 
-  /* drop a reference on the metadata if we own one */
-  if ((file->flags & THUNAR_FILE_OWNS_METAFILE_REFERENCE) != 0)
-    g_object_unref (G_OBJECT (metafile));
-
   /* release file info */
   if (file->info != NULL)
     g_object_unref (file->info);
@@ -518,31 +508,6 @@ thunar_file_denies_access_permission (const ThunarFile *file,
 
 
 
-static ThunarMetafile*
-thunar_file_get_metafile (ThunarFile *file)
-{
-  if ((file->flags & THUNAR_FILE_OWNS_METAFILE_REFERENCE) == 0)
-    {
-      /* take a reference on the metafile for this file */
-      if (G_UNLIKELY (metafile == NULL))
-        {
-          metafile = thunar_metafile_get_default ();
-          g_object_add_weak_pointer (G_OBJECT (metafile), (gpointer) &metafile);
-        }
-      else
-        {
-          g_object_ref (G_OBJECT (metafile));
-        }
-
-      /* remember that we own a reference now */
-      file->flags |= THUNAR_FILE_OWNS_METAFILE_REFERENCE;
-    }
-
-  return metafile;
-}
-
-
-
 static void
 thunar_file_monitor_update (GFile             *path,
                             GFileMonitorEvent  event_type)
@@ -599,6 +564,27 @@ thunar_file_monitor (GFileMonitor     *monitor,
 
 
 
+static void
+thunar_file_set_emblem_names_ready (GObject      *source_object,
+                                    GAsyncResult *result,
+                                    gpointer      user_data)
+{
+  ThunarFile *file = THUNAR_FILE (user_data);
+  GError     *error = NULL;
+
+  if (!g_file_set_attributes_finish (G_FILE (source_object), result, NULL, &error))
+    {
+      g_warning ("Failed to set metadata: %s", error->message);
+      g_error_free (error);
+
+      g_file_info_remove_attribute (file->info, "metadata:emblems");
+    }
+
+  thunar_file_changed (file);
+}
+
+
+
 /**
  * thunar_file_get:
  * @file  : a #GFile.
@@ -2613,28 +2599,15 @@ thunar_file_can_be_trashed (const ThunarFile *file)
 GList*
 thunar_file_get_emblem_names (ThunarFile *file)
 {
-  const gchar *emblem_string;
-  guint32      uid;
-  gchar      **emblem_names;
-  GList       *emblems = NULL;
+  guint32   uid;
+  gchar   **emblem_names;
+  GList    *emblems = NULL;
 
   _thunar_return_val_if_fail (THUNAR_IS_FILE (file), NULL);
-
-  /* check if we need to load the emblems_list from the metafile */
-  if (G_UNLIKELY ((file->flags & THUNAR_FILE_OWNS_EMBLEM_NAMES) == 0))
-    {
-      emblem_string = thunar_file_get_metadata (file, THUNAR_METAFILE_KEY_EMBLEMS, "");
-      if (G_UNLIKELY (*emblem_string != '\0'))
-        {
-          emblem_names = g_strsplit (emblem_string, ";", -1);
-          g_object_set_qdata_full (G_OBJECT (file), thunar_file_emblem_names_quark,
-                                   emblem_names, (GDestroyNotify) g_strfreev);
-        }
-      file->flags |= THUNAR_FILE_OWNS_EMBLEM_NAMES;
-    }
+  _thunar_return_val_if_fail (G_IS_FILE_INFO (file->info), NULL);
 
   /* determine the custom emblems */
-  emblem_names = g_object_get_qdata (G_OBJECT (file), thunar_file_emblem_names_quark);
+  emblem_names = g_file_info_get_attribute_stringv (file->info, "metadata::emblems");
   if (G_UNLIKELY (emblem_names != NULL))
     {
       for (; *emblem_names != NULL; ++emblem_names)
@@ -2686,12 +2659,13 @@ void
 thunar_file_set_emblem_names (ThunarFile *file,
                               GList      *emblem_names)
 {
-  GList  *lp;
-  gchar **emblems;
-  gchar  *emblems_string;
-  gint    n;
+  GList      *lp;
+  gchar     **emblems = NULL;
+  gint        n;
+  GFileInfo  *info;
 
   _thunar_return_if_fail (THUNAR_IS_FILE (file));
+  _thunar_return_if_fail (G_IS_FILE_INFO (file->info));
 
   /* allocate a zero-terminated array for the emblem names */
   emblems = g_new0 (gchar *, g_list_length (emblem_names) + 1);
@@ -2710,18 +2684,24 @@ thunar_file_set_emblem_names (ThunarFile *file,
       emblems[n++] = g_strdup (lp->data);
     }
 
-  /* associate the emblems with the file */
-  file->flags |= THUNAR_FILE_OWNS_EMBLEM_NAMES;
-  g_object_set_qdata_full (G_OBJECT (file), thunar_file_emblem_names_quark,
-                           emblems, (GDestroyNotify) g_strfreev);
+  /* set the value in the current info */
+  if (n == 0)
+    g_file_info_remove_attribute (file->info, "metadata::emblems");
+  else
+    g_file_info_set_attribute_stringv (file->info, "metadata::emblems", emblems);
 
-  /* store the emblem list in the file's metadata */
-  emblems_string = g_strjoinv (";", emblems);
-  thunar_file_set_metadata (file, THUNAR_METAFILE_KEY_EMBLEMS, emblems_string, "");
-  g_free (emblems_string);
+  /* set meta data to the daemon */
+  info = g_file_info_new ();
+  g_file_info_set_attribute_stringv (info, "metadata::emblems", emblems);
+  g_file_set_attributes_async (file->gfile, info,
+                               G_FILE_QUERY_INFO_NONE,
+                               G_PRIORITY_DEFAULT,
+                               NULL,
+                               thunar_file_set_emblem_names_ready,
+                               file);
+  g_object_unref (G_OBJECT (info));
 
-  /* tell everybody that we have changed */
-  thunar_file_changed (file);
+  g_strfreev (emblems);
 }
 
 
@@ -2989,68 +2969,6 @@ thunar_file_get_icon_name (const ThunarFile   *file,
 
 
 /**
- * thunar_file_get_metadata:
- * @file          : a #ThunarFile instance.
- * @key           : a #ThunarMetaFileKey.
- * @default_value : the default value for @key in @file
- *                  which is returned when @key isn't
- *                  explicitly set for @file (may be
- *                  %NULL).
- *
- * Returns the metadata available for @key in @file.
- *
- * The returned string is owned by the @file and uses
- * an internal buffer that will be overridden on the
- * next call to any of the metadata retrieval methods.
- *
- * Return value: the metadata available for @key in @file
- *               or @default_value if @key is not set for
- *               @file.
- **/
-const gchar*
-thunar_file_get_metadata (ThunarFile       *file,
-                          ThunarMetafileKey key,
-                          const gchar      *default_value)
-{
-  _thunar_return_val_if_fail (THUNAR_IS_FILE (file), NULL);
-  _thunar_return_val_if_fail (key < THUNAR_METAFILE_N_KEYS, NULL);
-
-  return thunar_metafile_fetch (thunar_file_get_metafile (file),
-                                file->gfile, key,
-                                default_value);
-}
-
-
-
-/**
- * thunar_file_set_metadata:
- * @file          : a #ThunarFile instance.
- * @key           : a #ThunarMetafileKey.
- * @value         : the new value for @key on @file.
- * @default_value : the default for @key on @file.
- *
- * Sets the metadata available for @key in @file to
- * the given @value.
- **/
-void
-thunar_file_set_metadata (ThunarFile       *file,
-                          ThunarMetafileKey key,
-                          const gchar      *value,
-                          const gchar      *default_value)
-{
-  _thunar_return_if_fail (THUNAR_IS_FILE (file));
-  _thunar_return_if_fail (key < THUNAR_METAFILE_N_KEYS);
-  _thunar_return_if_fail (default_value != NULL);
-  _thunar_return_if_fail (value != NULL);
-
-  thunar_metafile_store (thunar_file_get_metafile (file),
-                         file->gfile, key, value,
-                         default_value);
-}
-
-
-
-/**
  * thunar_file_watch:
  * @file : a #ThunarFile instance.
  *
index d1a5704..70e9df8 100644 (file)
@@ -27,7 +27,6 @@
 
 #include <thunar/thunar-enum-types.h>
 #include <thunar/thunar-gio-extensions.h>
-#include <thunar/thunar-metafile.h>
 #include <thunar/thunar-user.h>
 
 G_BEGIN_DECLS;
@@ -232,14 +231,6 @@ gchar            *thunar_file_get_icon_name        (const ThunarFile        *fil
                                                     ThunarFileIconState     icon_state,
                                                     GtkIconTheme           *icon_theme);
 
-const gchar      *thunar_file_get_metadata         (ThunarFile             *file,
-                                                    ThunarMetafileKey       key,
-                                                    const gchar            *default_value);
-void              thunar_file_set_metadata         (ThunarFile             *file,
-                                                    ThunarMetafileKey       key,
-                                                    const gchar            *value,
-                                                    const gchar            *default_value);
-
 void              thunar_file_watch                (ThunarFile             *file);
 void              thunar_file_unwatch              (ThunarFile             *file);
 
diff --git a/thunar/thunar-metafile.c b/thunar/thunar-metafile.c
deleted file mode 100644 (file)
index 03be917..0000000
+++ /dev/null
@@ -1,458 +0,0 @@
-/* $Id$ */
-/*-
- * Copyright (c) 2005-2006 Benedikt Meurer <benny@xfce.org>
- * Copyright (c) 2009-2011 Jannis Pohlmann <jannis@xfce.org>
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the Free
- * Software Foundation; either version 2 of the License, or (at your option)
- * any later version.
- *
- * This program 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 General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
- * Place, Suite 330, Boston, MA  02111-1307  USA
- */
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#ifdef HAVE_ERRNO_H
-#include <errno.h>
-#endif
-#ifdef HAVE_FCNTL_H
-#include <fcntl.h>
-#endif
-#ifdef HAVE_MEMORY_H
-#include <memory.h>
-#endif
-#ifdef HAVE_STDLIB_H
-#include <stdlib.h>
-#endif
-#ifdef HAVE_STRING_H
-#include <string.h>
-#endif
-
-#include <gio/gio.h>
-
-#include <exo/exo.h>
-
-#include <tdb/tdb.h>
-
-#include <thunar/thunar-metafile.h>
-#include <thunar/thunar-private.h>
-
-
-
-static void     thunar_metafile_class_init  (ThunarMetafileClass  *klass);
-static void     thunar_metafile_init        (ThunarMetafile       *metafile);
-static void     thunar_metafile_finalize    (GObject              *object);
-static TDB_DATA thunar_metafile_read        (ThunarMetafile       *metafile,
-                                             TDB_DATA              data);
-
-
-
-struct _ThunarMetafileClass
-{
-  GObjectClass __parent__;
-};
-
-struct _ThunarMetafile
-{
-  GObject __parent__;
-
-  TDB_CONTEXT *context;
-  TDB_DATA     data;
-};
-
-
-
-static GObjectClass *thunar_metafile_parent_class;
-
-
-
-GType
-thunar_metafile_get_type (void)
-{
-  static GType type = G_TYPE_INVALID;
-
-  if (G_UNLIKELY (type == G_TYPE_INVALID))
-    {
-      static const GTypeInfo info =
-      {
-        sizeof (ThunarMetafileClass),
-        NULL,
-        NULL,
-        (GClassInitFunc) thunar_metafile_class_init,
-        NULL,
-        NULL,
-        sizeof (ThunarMetafile),
-        0,
-        (GInstanceInitFunc) thunar_metafile_init,
-        NULL,
-      };
-
-      type = g_type_register_static (G_TYPE_OBJECT, I_("ThunarMetafile"), &info, 0);
-    }
-
-  return type;
-}
-
-
-
-static void
-thunar_metafile_class_init (ThunarMetafileClass *klass)
-{
-  GObjectClass *gobject_class;
-
-  /* determine the parent type class */
-  thunar_metafile_parent_class = g_type_class_peek_parent (klass);
-
-  gobject_class = G_OBJECT_CLASS (klass);
-  gobject_class->finalize = thunar_metafile_finalize;
-}
-
-
-
-static void
-thunar_metafile_init (ThunarMetafile *metafile)
-{
-  gchar *path;
-
-  /* determine the path to the metafile database (create directories as required) */
-  path = xfce_resource_save_location (XFCE_RESOURCE_CACHE, "Thunar/metafile.tdb", TRUE);
-  if (G_UNLIKELY (path == NULL))
-    {
-      path = xfce_resource_save_location (XFCE_RESOURCE_CACHE, "Thunar/", FALSE);
-      g_warning ("Failed to create the Thunar cache directory in %s", path);
-      g_free (path);
-      return;
-    }
-
-  /* try to open the metafile database file */
-  metafile->context = tdb_open (path, 0, TDB_DEFAULT, O_CREAT | O_RDWR, 0600);
-  if (G_UNLIKELY (metafile->context == NULL))
-    g_warning ("Failed to open metafile database in %s: %s.", path, g_strerror (errno));
-
-  /* release the path */
-  g_free (path);
-}
-
-
-
-static void
-thunar_metafile_finalize (GObject *object)
-{
-  ThunarMetafile *metafile = THUNAR_METAFILE (object);
-
-  /* close the database (if open) */
-  if (G_LIKELY (metafile->context != NULL))
-    tdb_close (metafile->context);
-
-  /* release any pending data */
-  if (G_LIKELY (metafile->data.dptr != NULL))
-    free (metafile->data.dptr);
-
-  (*G_OBJECT_CLASS (thunar_metafile_parent_class)->finalize) (object);
-}
-
-
-
-static TDB_DATA
-thunar_metafile_read (ThunarMetafile *metafile,
-                      TDB_DATA        data)
-{
-  /* perform the fetch operation on the database */
-  data = tdb_fetch (metafile->context, data);
-  if (G_UNLIKELY (data.dptr != NULL))
-    {
-      /* validate the result */
-      if (data.dsize < sizeof (guint32)
-          || (data.dsize % sizeof (guint32)) != 0
-          || data.dptr[data.dsize - 1] != '\0')
-        {
-          free (data.dptr);
-          data.dptr = NULL;
-          data.dsize = 0;
-        }
-    }
-
-  return data;
-}
-
-
-
-/**
- * thunar_metafile_get_default:
- *
- * Returns a reference to the default #ThunarMetafile
- * instance. There can be only one #ThunarMetafile
- * instance at any time.
- *
- * The caller is responsible to free the returned
- * object using g_object_unref() when no longer
- * needed.
- *
- * Return value: a reference to the default #ThunarMetafile
- *               instance.
- **/
-ThunarMetafile*
-thunar_metafile_get_default (void)
-{
-  static ThunarMetafile *metafile = NULL;
-
-  if (G_UNLIKELY (metafile == NULL))
-    {
-      /* allocate a new metafile instance. */
-      metafile = g_object_new (THUNAR_TYPE_METAFILE, NULL);
-      g_object_add_weak_pointer (G_OBJECT (metafile), (gpointer) &metafile);
-    }
-  else
-    {
-      /* take a reference for the caller */
-      g_object_ref (G_OBJECT (metafile));
-    }
-
-  return metafile;
-}
-
-
-
-/**
- * thunar_metafile_fetch:
- * @metafile      : a #ThunarMetafile.
- * @file          : a #Gfile.
- * @key           : a #ThunarMetafileKey.
- * @default_value : the default value for @key,
- *                  which may be %NULL.
- *
- * Fetches the value for @key on @path in
- * @metafile. Returns a pointer to the
- * value if found, or the default value
- * if the @key is explicitly not set for
- * @path in @metafile, as specified in
- * @default_value.
- *
- * The returned string is owned by @metafile
- * and is only valid until the next call to
- * thunar_metafile_fetch(), so you might need
- * to take a copy of the value if you need to
- * keep for a longer period.
- *
- * Return value: the value for @key on @path
- *               in @metafile or the default
- *               value for @key, as specified
- *               by @default_value.
- **/
-const gchar*
-thunar_metafile_fetch (ThunarMetafile   *metafile,
-                       GFile            *file,
-                       ThunarMetafileKey key,
-                       const gchar      *default_value)
-{
-  const guchar *dend;
-  const guchar *dp;
-  TDB_DATA      key_data;
-  gssize        key_size;
-  gchar        *key_path = NULL;
-
-  _thunar_return_val_if_fail (THUNAR_IS_METAFILE (metafile), NULL);
-  _thunar_return_val_if_fail (G_IS_FILE (file), NULL);
-  _thunar_return_val_if_fail (key < THUNAR_METAFILE_N_KEYS, NULL);
-
-  /* check if the database handle is available */
-  if (G_UNLIKELY (metafile->context == NULL))
-    goto use_default_value;
-
-  /* determine the string representation of the path (using the URI for non-local paths) */
-  key_path = g_file_get_uri (file);
-  key_size = strlen (key_path);
-
-  if (G_UNLIKELY (key_size <= 0))
-    goto use_default_value;
-
-  /* generate the key data */
-  key_data.dptr = key_path;
-  key_data.dsize = key_size;
-
-  /* release any earlier result data */
-  if (G_LIKELY (metafile->data.dptr != NULL))
-    free (metafile->data.dptr);
-
-  /* perform the fetch operation on the database */
-  metafile->data = thunar_metafile_read (metafile, key_data);
-  if (G_LIKELY (metafile->data.dptr == NULL))
-    goto use_default_value;
-
-  /* lookup the value for the given key */
-  dp = (const guchar *) metafile->data.dptr;
-  dend = dp + metafile->data.dsize;
-  for (;;)
-    {
-      /* check if we have a match */
-      if (*dp == (guint) key)
-        {
-          g_free (key_path);
-          return (const gchar *) (dp + 1);
-        }
-
-      /* lookup the next entry */
-      do
-        {
-          /* skip another 4 bytes */
-          dp += sizeof (guint32);
-          if (G_UNLIKELY (dp == dend))
-            goto use_default_value;
-        }
-      while (*(dp - 1) != '\0');
-    }
-
-  /* use the default value */
-use_default_value:
-  g_free (key_path);
-  return default_value;
-}
-
-
-
-/**
- * thunar_metafile_store:
- * @metafile      : a #ThunarMetafile.
- * @file          : a #GFile.
- * @key           : a #ThunarMetafileKey.
- * @value         : the new value for @key on @path.
- * @default_value : the default value for @key on @path.
- *
- * Stores the given @value for @key on @path in
- * @metafile.
- *
- * No error is returned from this method, but
- * the store operation may nevertheless fail,
- * so don't depend on the success of the operation.
- *
- * Note that if @value equals the @default_value
- * for @key, it isn't stored in the @metafile to
- * save memory.
- **/
-void
-thunar_metafile_store (ThunarMetafile   *metafile,
-                       GFile            *file,
-                       ThunarMetafileKey key,
-                       const gchar      *value,
-                       const gchar      *default_value)
-{
-  TDB_DATA value_data;
-  TDB_DATA key_data;
-  gssize   value_size;
-  gssize   key_size;
-  gchar   *buffer;
-  gchar   *bp;
-  gchar   *key_path;
-
-  _thunar_return_if_fail (THUNAR_IS_METAFILE (metafile));
-  _thunar_return_if_fail (G_IS_FILE (file));
-  _thunar_return_if_fail (key < THUNAR_METAFILE_N_KEYS);
-  _thunar_return_if_fail (value != NULL);
-  _thunar_return_if_fail (default_value != NULL);
-
-  /* check if the database handle is available */
-  if (G_UNLIKELY (metafile->context == NULL))
-    return;
-
-  /* determine the string representation of the file */
-  key_path = g_file_get_uri (file);
-  key_size = strlen (key_path);
-
-  if (G_UNLIKELY (key_size <= 0))
-    return;
-
-  /* generate the key data */
-  key_data.dptr = key_path;
-  key_data.dsize = key_size;
-
-  /* fetch the current value for the key */
-  value_data = thunar_metafile_read (metafile, key_data);
-
-  /* determine the size required for the new value */
-  value_size = strlen (value) + 2;
-  value_size = ((value_size + sizeof (guint32) - 1) / sizeof (guint32)) * sizeof (guint32);
-
-  /* allocate a buffer to merge the existing value set with the new value */
-  buffer = g_new0 (gchar, value_data.dsize + value_size);
-
-  /* copy the new value to the buffer if it's not equal to the default value */
-  if (G_LIKELY (strcmp (value, default_value) != 0))
-    {
-      buffer[0] = key;
-      strcpy (buffer + 1, value);
-      bp = buffer + value_size;
-    }
-  else
-    {
-      bp = buffer;
-    }
-
-  /* copy the existing entries (if any) */
-  if (G_LIKELY (value_data.dptr != NULL))
-    {
-      const guchar *vp = (const guchar *) value_data.dptr;
-      const guchar *vend = vp + value_data.dsize;
-      const guchar *vx;
-
-      for (; vp < vend; vp = vx)
-        {
-          /* grab a pointer to the next entry (thereby calc
-           * the length of this entry).
-           */
-          for (vx = vp + sizeof (guint32); *(vx - 1) != '\0'; vx += sizeof (guint32))
-            ;
-
-          /* verify the vx pointer */
-          _thunar_assert (vx <= vend);
-          _thunar_assert (vx > vp);
-
-          /* check if we should copy the entry */
-          if (*vp != key)
-            {
-              memcpy (bp, vp, vx - vp);
-              bp += (vx - vp);
-            }
-        }
-
-      /* verify the buffer space */
-      _thunar_assert (bp <= buffer + value_data.dsize + value_size);
-      _thunar_assert ((bp - buffer) % sizeof (guint32) == 0);
-
-      /* release the previous value set */
-      free (value_data.dptr);
-    }
-
-  /* delete the key from the database if the new
-   * value set is the same as the default value set.
-   */
-  if (G_UNLIKELY (bp == buffer))
-    {
-      tdb_delete (metafile->context, key_data);
-    }
-  else
-    {
-      /* setup the new value set */
-      value_data.dptr = buffer;
-      value_data.dsize = bp - buffer;
-
-      /* execute the store operation */
-      tdb_store (metafile->context, key_data, value_data, TDB_REPLACE);
-    }
-
-  /* free the file URI */
-  g_free (key_path);
-
-  /* free the buffer space */
-  g_free (buffer);
-}
-
diff --git a/thunar/thunar-metafile.h b/thunar/thunar-metafile.h
deleted file mode 100644 (file)
index bd70d1f..0000000
+++ /dev/null
@@ -1,65 +0,0 @@
-/* $Id$ */
-/*-
- * Copyright (c) 2005 Benedikt Meurer <benny@xfce.org>
- * Copyright (c) 2009 Jannis Pohlmann <jannis@xfce.org>
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the Free
- * Software Foundation; either version 2 of the License, or (at your option)
- * any later version.
- *
- * This program 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 General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
- * Place, Suite 330, Boston, MA  02111-1307  USA
- */
-
-#ifndef __THUNAR_METAFILE_H__
-#define __THUNAR_METAFILE_H__
-
-#include <gio/gio.h>
-
-G_BEGIN_DECLS;
-
-typedef struct _ThunarMetafileClass ThunarMetafileClass;
-typedef struct _ThunarMetafile      ThunarMetafile;
-
-#define THUNAR_TYPE_METAFILE            (thunar_metafile_get_type ())
-#define THUNAR_METAFILE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), THUNAR_TYPE_METAFILE, ThunarMetafile))
-#define THUNAR_METAFILE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), THUNAR_TYPE_METAFILE, ThunarMetafileClass))
-#define THUNAR_IS_METAFILE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), THUNAR_TYPE_METAFILE))
-#define THUNAR_IS_METAFILE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), THUNAR_TYPE_METAFILE))
-#define THUNAR_METAFILE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), THUNAR_TYPE_METAFILE, ThunarMetafileClass))
-
-/**
- * ThunarMetafileKey:
- * @THUNAR_METAFILE_KEY_EMBLEMS :
- **/
-typedef enum /*< enum >*/
-{
-  THUNAR_METAFILE_KEY_EMBLEMS,
-  THUNAR_METAFILE_N_KEYS,
-} ThunarMetafileKey;
-
-GType           thunar_metafile_get_type    (void) G_GNUC_CONST;
-
-ThunarMetafile *thunar_metafile_get_default (void);
-
-const gchar    *thunar_metafile_fetch       (ThunarMetafile   *metafile,
-                                             GFile            *file,
-                                             ThunarMetafileKey key,
-                                             const gchar      *default_value);
-
-void            thunar_metafile_store       (ThunarMetafile   *metafile,
-                                             GFile            *file,
-                                             ThunarMetafileKey key,
-                                             const gchar      *value,
-                                             const gchar      *default_value);
-
-G_END_DECLS;
-
-#endif /* !__THUNAR_METAFILE_H__ */
index 13a7001..0e78600 100644 (file)
@@ -45,7 +45,8 @@ G_BEGIN_DECLS;
   "time::*," \
   "thumbnail::*," \
   "trash::*," \
-  "unix::*"
+  "unix::*," \
+  "metadata::emblems"
 
 /**
  * Filesystem information namespaces available in the #GFileInfo