chiark / gitweb /
[PATCH] replace tdb database by simple lockless file database
authorkay.sievers@vrfy.org <kay.sievers@vrfy.org>
Sat, 6 Nov 2004 13:28:01 +0000 (14:28 +0100)
committerGreg KH <gregkh@suse.de>
Wed, 27 Apr 2005 05:16:40 +0000 (22:16 -0700)
This makes the udev operation completely lockless by storing a
file for every node in /dev/.udevdb/* This solved the problem
with deadlocking concurrent udev processes waiting for each other
to release the file lock under heavy load.

41 files changed:
HOWTO-udev_for_dev
Makefile
dev_d.c
docs/persistent_naming/testing_scsi_notes.txt
etc/init.d/udev
etc/udev/udev.conf.in
namedev.c
tdb/Makefile [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/tdb.magic [deleted file]
tdb/tdbback.c [deleted file]
tdb/tdbback.h [deleted file]
tdb/tdbbackup.c [deleted file]
tdb/tdbdump.c [deleted file]
tdb/tdbutil.c [deleted file]
tdb/tdbutil.h [deleted file]
test/devd_test
test/ignore_test
test/label_test
test/modifier_test
test/net_test
test/replace_test
test/topo_test
test/udev-test.pl
udev.8.in
udev.c
udev.h
udev_add.c
udev_config.c
udev_lib.c
udev_lib.h
udev_remove.c
udevdb.c
udevdb.h
udevinfo.8
udevinfo.c
udevsend.c

index 58bf2d4..9833dd1 100644 (file)
@@ -39,10 +39,10 @@ NOTE NOTE NOTE NOTE NOTE NOTE NOTE
    the end of this file.
 
  - make sure the /etc/udev/udev.conf file lists the udev_root as "/dev/"
-   and the udev_db as "/dev/.udev.tdb". It should contain the
+   and the udev_db as "/dev/.udevdb". It should contain the
    following lines in order to work properly.
        udev_root="/dev/"
-       udev_db="/dev/.udev.tdb"
+       udev_db="/dev/.udevdb"
 
  - reboot into a 2.6 kernel and watch udev create all of the initial
    device nodes in /dev
index 6763028..ef66213 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -68,7 +68,8 @@ INSTALL_SCRIPT = ${INSTALL_PROGRAM}
 EXTRAS=
 
 # place to put our device nodes
-udevdir = ${prefix}/udev
+udevdir =      ${prefix}/udev
+udevdb =       ${udevdir}/.udevdb
 
 # Comment out this line to build with something other 
 # than the local version of klibc
@@ -113,11 +114,6 @@ WARNINGS := -Wall
 
 CFLAGS := -pipe
 
-# set up the proper tdb spinlock code if we can
-ifeq ($(strip $(ARCH)),i386)
-       CFLAGS += -DUSE_SPINLOCKS -DINTEL_SPINLOCKS
-endif
-
 ifeq ($(strip $(USE_LOG)),true)
        CFLAGS  += -DLOG
 endif
@@ -201,9 +197,6 @@ $(CRT0):
        fi
        $(MAKE) -C klibc SUBDIRS=klibc
 
-TDB =  tdb/tdb.o       \
-       tdb/spinlock.o
-
 SYSFS =        $(PWD)/libsysfs/sysfs_bus.o     \
        $(PWD)/libsysfs/sysfs_class.o   \
        $(PWD)/libsysfs/sysfs_device.o  \
@@ -221,8 +214,7 @@ OBJS =      udev_lib.o      \
        namedev.o       \
        namedev_parse.o \
        dev_d.o         \
-       $(SYSFS)        \
-       $(TDB)
+       $(SYSFS)
 
 HEADERS =      udev.h          \
                udev_lib.h      \
@@ -262,8 +254,8 @@ ccdv:
 udev_version.h:
        @echo "Creating udev_version.h"
        @echo \#define UDEV_VERSION             \"$(VERSION)\" > $@
-       @echo \#define UDEV_ROOT                \"$(udevdir)/\" >> $@
-       @echo \#define UDEV_DB                  \"$(udevdir)/.udev.tdb\" >> $@
+       @echo \#define UDEV_ROOT                \"$(udevdir)\" >> $@
+       @echo \#define UDEV_DB                  \"$(udevdb)\" >> $@
        @echo \#define UDEV_CONFIG_DIR          \"$(configdir)\" >> $@
        @echo \#define UDEV_CONFIG_FILE         \"$(configdir)/udev.conf\" >> $@
        @echo \#define UDEV_RULES_FILE          \"$(configdir)/rules.d\" >> $@
@@ -300,7 +292,7 @@ $(TESTER): $(LIBC) $(TESTER).o $(OBJS) $(HEADERS)
        $(QUIET) $(STRIPCMD) $@
 
 $(INFO): $(LIBC) $(INFO).o $(OBJS) $(HEADERS)
-       $(QUIET) $(LD) $(LDFLAGS) -o $@ $(CRT0) udevinfo.o udev_lib.o udev_config.o udevdb.o $(SYSFS) $(TDB) $(LIB_OBJS) $(ARCH_LIB_OBJS)
+       $(QUIET) $(LD) $(LDFLAGS) -o $@ $(CRT0) udevinfo.o udev_lib.o udev_config.o udevdb.o $(SYSFS) $(LIB_OBJS) $(ARCH_LIB_OBJS)
        $(QUIET) $(STRIPCMD) $@
 
 $(DAEMON): $(LIBC) $(DAEMON).o $(OBJS) udevd.h
@@ -337,7 +329,7 @@ spotless: clean
        $(MAKE) -C klibc spotless
        -rm -f klibc/linux
 
-DISTFILES = $(shell find . \( -not -name '.' \) -print | grep -v -e CVS -e "\.tar\.gz$" -e "\/\." -e releases -e BitKeeper -e SCCS -e "\.tdb$" -e test/sys | sort )
+DISTFILES = $(shell find . \( -not -name '.' \) -print | grep -v -e CVS -e "\.tar\.gz" -e "\/\." -e releases -e BitKeeper -e SCCS -e test/sys | sort )
 DISTDIR := $(RELEASE_NAME)
 srcdir = .
 release: clean
@@ -429,8 +421,8 @@ install: install-initscript install-config install-man install-dev.d all
        - ln -f -s $(sbindir)/$(SENDER) $(DESTDIR)$(hotplugdir)/10-udev.hotplug
        - ln -f -s $(sbindir)/$(WAIT) $(DESTDIR)$(hotplugdir)/05-wait_for_sysfs.hotplug
 ifndef DESTDIR
-       - killall udevd
-       - rm -f $(udevdir)/.udev.tdb
+       - killall $(DAEMON)
+       - rm -rf $(udevdb)
 endif
        @extras="$(EXTRAS)" ; for target in $$extras ; do \
                echo $$target ; \
@@ -456,8 +448,9 @@ uninstall: uninstall-man uninstall-dev.d
        - rm $(usrbindir)/$(TESTER)
        - rm $(usrbindir)/$(WAIT)
        - rmdir $(hotplugdir)
-       - rm $(udevdir)/.udev.tdb
+       - rm -rf $(udevdb)
        - rmdir $(udevdir)
+       - killall $(DAEMON)
        @extras="$(EXTRAS)" ; for target in $$extras ; do \
                echo $$target ; \
                $(MAKE) prefix=$(prefix) LD="$(LD)" SYSFS="$(SYSFS)" \
diff --git a/dev_d.c b/dev_d.c
index 64c2544..6e35f55 100644 (file)
--- a/dev_d.c
+++ b/dev_d.c
@@ -47,7 +47,6 @@ static int run_program(char *name)
        switch (pid) {
        case 0:
                /* child */
-               udevdb_exit();  /* close udevdb */
                fd = open("/dev/null", O_RDWR);
                if ( fd >= 0) {
                        dup2(fd, STDOUT_FILENO);
index 8d94c84..728b40b 100644 (file)
@@ -110,10 +110,8 @@ uses:
 (1) /sys maintained by sysfs 
 (2) /etc/udev/udev.rules - where you can store the identifier to NAME
     mapping information.
-(3) The tdb (udev-021/tdb/tdb.c),  trivial data base,  that is held in
-    memory and holds the valid system configuration.  It is not saved
-    between one boot to the next.  It is constructed at boot time and
-    updated with configuration changes.
+(3) The udevdb, that keeps track the valid system configuration.
+    It is constructed at boot time and updated with configuration changes.
 
 The persistent names are kept (at least this is one way to do it) in
 udev.rules (uuid and NAME), one entry per device.  If you want to initially
@@ -148,9 +146,9 @@ the device.  The result of the program execution (the uuid)  is compared
 with the RESULT entry in the same udev.rules line.  
 
 - If it matches, then the NAME entered on this line is used.  The uuid and
-  major/minor number is saved in tdb (newly recreated upon boot).  That
-  device is created in /udev (the target directory name is configurable)
-  with the assigned NAME.    
+  major/minor number is saved in the udevdb (newly recreated upon boot).
+  That device is created in /udev (the target directory name is configurable)
+  with the assigned NAME.
 
 - If it doesn't match, the RESULT (uuid) is preserved for use on the next
   udev.rules line as long as the bus type (scsi) is the same.  So the
@@ -159,18 +157,18 @@ with the RESULT entry in the same udev.rules line.
 
 - If no match occurs, the device will be assigned a default name.  
 
-- Tdb is updated with the resulting name assignment.
+- The udevdb is updated with the resulting name assignment.
 
 
 Thus if the uuid and names are enumerated, they will be found, assigned,
 and are therefore permanent.
 
 If the device is removed from a live system, a hotplug event occurs, and it
-is removed from tdb and the /udev entry disappears.
+is removed from udevdb and the /udev entry disappears.
 
 If it is re-inserted at a new location, the udev.rules file is scanned as
-above.  The new major/minor number goes in tdb with the uuid , the name in
-udev.rules is found again,  and the /udev name re-appears.
+above.  The rule matches again against the uuid, the name in udev.rules
+is applied again and the /udev name re-appears.
 
 
 
index 7e6305a..8726090 100644 (file)
@@ -79,8 +79,8 @@ case "$1" in
        fi
 
        # remove the database if it is there as we always want to start fresh
-       if [ -f $udev_root/.udev.tdb ]; then
-               rm -f $udev_root/.udev.tdb
+       if [ -f $udev_root/.udevdb ]; then
+               rm -rf $udev_root/.udevdb
        fi
 
        # propogate /udev from /sys - we only need this while we do not
index 4c71b1d..bbbb1a9 100644 (file)
@@ -6,16 +6,16 @@
 
 
 # udev_root - where in the filesystem to place the device nodes
-udev_root="@udevdir@/"
+udev_root="@udevdir@"
 
 # udev_db - The name and location of the udev database.
-udev_db="@udevdir@/.udev.tdb"
+udev_db="@udevdir@/.udevdb"
 
 # udev_rules - The name and location of the udev rules file
-udev_rules="@configdir@/rules.d/"
+udev_rules="@configdir@/rules.d"
 
 # udev_permissions - The name and location of the udev permission file
-udev_permissions="@configdir@/permissions.d/"
+udev_permissions="@configdir@/permissions.d"
 
 # default_mode - set the default mode for all nodes that have no
 #                explicit match in the permissions file
index f3fb3ff..d63e36e 100644 (file)
--- a/namedev.c
+++ b/namedev.c
@@ -184,29 +184,29 @@ static int get_format_len(char **str)
  *  @param  name                Name to check for
  *  @return                     0 if <name> didn't exist and N otherwise.
  */
-static unsigned int find_free_number (struct udevice *udev, char *name)
+static int find_free_number(struct udevice *udev, const char *name)
 {
-       char temp[NAME_SIZE];
-       char path[NAME_SIZE];
-       struct udevice dev;
-       int result;
+       char filename[NAME_SIZE];
+       int num = 0;
+       struct udevice db_udev;
 
-       /* have to sweep the database for each lookup */
-       result = 0;
-       strncpy(temp, name, sizeof (temp));
+       strfieldcpy(filename, name);
        while (1) {
-               if (udevdb_get_dev_byname(temp, path, &dev) != 0)
-                       goto found;
-               /* symlink might be stale if $(udevroot) isn't cleaned; check
-                * on major/minor to see if it's the same device
-                */
-               if (dev.major == udev->major && dev.minor == udev->minor)
-                       goto found;
-               snprintf (temp, sizeof(temp), "%s%d", name, ++result);
-       }
+               dbg("look for existing node '%s'", filename);
+               memset(&db_udev, 0x00, sizeof(struct udevice));
+               if (udevdb_get_dev_byname(&db_udev, filename) != 0) {
+                       dbg("free num=%d", num);
+                       return num;
+               }
 
-found:
-       return result;
+               num++;
+               if (num > 1000) {
+                       info("find_free_number gone crazy (num=%d), aborted", num);
+                       return -1;
+               }
+               snprintf(filename, NAME_SIZE-1, "%s%d", name, num);
+               filename[NAME_SIZE-1] = '\0';
+       }
 }
 
 static void apply_format(struct udevice *udev, char *string, size_t maxsize,
@@ -329,7 +329,7 @@ static void apply_format(struct udevice *udev, char *string, size_t maxsize,
                case 'e':
                        next_free_number = find_free_number(udev, string);
                        if (next_free_number > 0) {
-                               snprintf(temp2, sizeof(temp2), "%d", next_free_number);
+                               sprintf(temp2, "%d", next_free_number);
                                strfieldcatmax(string, temp2, maxsize);
                        }
                        break;
diff --git a/tdb/Makefile b/tdb/Makefile
deleted file mode 100644 (file)
index 87fb680..0000000
+++ /dev/null
@@ -1,32 +0,0 @@
-#
-# Makefile for tdb directory
-#
-
-CFLAGS = -DSTANDALONE -DTDB_DEBUG -g -DHAVE_MMAP=1
-
-PROGS = tdbtest tdbtool tdbtorture
-TDB_OBJ = tdb.o spinlock.o
-
-default: $(TDB_OBJ)
-
-progs: $(PROGS)
-
-tdbtest: tdbtest.o $(TDB_OBJ)
-       $(CC) $(CFLAGS) -o tdbtest tdbtest.o $(TDB_OBJ) -lgdbm
-
-tdbtool: tdbtool.o $(TDB_OBJ)
-       $(CC) $(CFLAGS) -o tdbtool tdbtool.o $(TDB_OBJ)
-
-tdbtorture: tdbtorture.o $(TDB_OBJ)
-       $(CC) $(CFLAGS) -o tdbtorture tdbtorture.o $(TDB_OBJ)
-
-tdbdump: tdbdump.o $(TDB_OBJ)
-       $(CC) $(CFLAGS) -o tdbdump tdbdump.o $(TDB_OBJ)
-
-tdbbackup: tdbbackup.o $(TDB_OBJ)
-       $(CC) $(CFLAGS) -o tdbbackup tdbbackup.o $(TDB_OBJ)
-
-clean:
-       rm -f $(PROGS) *.o *~ *% core test.db test.tdb test.gdbm
-
-spotless: clean
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 451617f..0000000
+++ /dev/null
@@ -1,433 +0,0 @@
-/* 
-   Unix SMB/CIFS implementation.
-   Samba database functions
-   Copyright (C) Anton Blanchard                   2001
-   
-   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., 675 Mass Ave, Cambridge, MA 02139, USA.
-*/
-/* udev defines */
-#define STANDALONE
-#define TDB_DEBUG
-#define HAVE_MMAP      1
-
-#if HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#ifdef STANDALONE
-#define _KLIBC_HAS_ARCH_SIG_ATOMIC_T
-#include <stdlib.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <string.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <sys/stat.h>
-#include <time.h>
-#include <signal.h>
-#include "tdb.h"
-#include "spinlock.h"
-#include "../udev.h"
-#include "../logging.h"
-
-#else
-#include "includes.h"
-#endif
-
-#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) 
-
-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 USE_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)
-{
-       return 0;
-}
-
-/*
- * 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);
-
-       if (!(rwlock->count & RWLOCK_BIAS))
-               dbg("bug: write_unlock");
-
-       rwlock->count &= ~RWLOCK_BIAS;
-       __spin_unlock(&rwlock->lock);
-}
-
-static void __read_unlock(tdb_rwlock_t *rwlock)
-{
-       __spin_lock(&rwlock->lock);
-
-       if (!rwlock->count)
-               dbg("bug: read_unlock");
-
-       if (rwlock->count & RWLOCK_BIAS)
-               dbg("bug: read_unlock");
-
-       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 = (hash_size + 1) * sizeof(tdb_rwlock_t);
-       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 8b0e833..0000000
+++ /dev/null
@@ -1,55 +0,0 @@
-#ifndef __SPINLOCK_H__
-#define __SPINLOCK_H__
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include "tdb.h"
-
-#ifdef USE_SPINLOCKS
-
-#define RWLOCK_BIAS 0x1000UL
-
-/* OS SPECIFIC */
-#define MAX_BUSY_LOOPS 1000
-#undef USE_SCHED_YIELD
-
-/* 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;
-
-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);
-
-#else /* !USE_SPINLOCKS */
-#if 0
-#define tdb_create_rwlocks(fd, hash_size) 0
-#define tdb_spinlock(tdb, list, rw_type) (-1)
-#define tdb_spinunlock(tdb, list, rw_type) (-1)
-#else
-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);
-#endif
-int tdb_clear_spinlocks(TDB_CONTEXT *tdb);
-#endif
-
-#endif
diff --git a/tdb/tdb.c b/tdb/tdb.c
deleted file mode 100644 (file)
index af475bb..0000000
--- a/tdb/tdb.c
+++ /dev/null
@@ -1,2099 +0,0 @@
- /* 
-   Unix SMB/CIFS implementation.
-   Samba database functions
-   Copyright (C) Andrew Tridgell              1999-2000
-   Copyright (C) Luke Kenneth Casson Leighton      2000
-   Copyright (C) Paul `Rusty' Russell             2000
-   Copyright (C) Jeremy Allison                           2000-2003
-   
-   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., 675 Mass Ave, Cambridge, MA 02139, USA.
-*/
-
-
-/* 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.
- */ 
-
-/* udev defines */
-#define STANDALONE
-#define TDB_DEBUG
-#define HAVE_MMAP      1
-/* this should prevent deadlocks loops on corrupt databases
- * we've discovered. Most deadlocks happend by iterating over the
- * list of entries with the same hash value. */
-#define LOOP_MAX       100000
-#define TDB_LOG(x) TDB_LOG_UDEV x
-#define TDB_LOG_UDEV(tdb, level, format, arg...) info(format, ##arg)
-
-#ifdef STANDALONE
-#if HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#define _KLIBC_HAS_ARCH_SIG_ATOMIC_T
-#include <stdlib.h>
-#include <stdio.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <string.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <signal.h>
-#include "tdb.h"
-#include "spinlock.h"
-#include "../udev_lib.h"
-#include "../logging.h"
-#else
-#include "includes.h"
-#endif
-
-#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))
-
-/* NB assumes there is a local variable called "tdb" that is the
- * current context, also takes doubly-parenthesized print-style
- * argument. */
-#ifndef TDB_LOG
-#define TDB_LOG(x) (tdb->log_fn?((tdb->log_fn x),0) : 0)
-#endif
-
-/* 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)
-                       return TDB_ERRCODE(TDB_ERR_LOCK_TIMEOUT, -1);
-               /* Otherwise - generic lock error. */
-               /* errno set by fcntl */
-               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;
-}
-
-/* This is based on the hash algorithm from gdbm */
-static u32 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);  
-}
-
-/* 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 < (size_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;
-
-       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);
-       }
-
-       return tdb_unlock(tdb, i, F_WRLCK);
-}
-
-void tdb_dump_all(TDB_CONTEXT *tdb)
-{
-       int i;
-       for (i=0;i<tdb->header.hash_size;i++) {
-               tdb_dump_chain(tdb, i);
-       }
-       printf("freelist:\n");
-       tdb_dump_chain(tdb, -1);
-}
-
-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;
-       int maxloop;
-
-       /* read in the freelist top */
-       maxloop = LOOP_MAX;
-       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;
-
-               maxloop--;
-               if (maxloop == 0) {
-                       TDB_LOG((tdb, 0, "remove_from_freelist: maxloop reached; corrupt database!\n"));
-                       return TDB_ERRCODE(TDB_ERR_CORRUPT, -1);
-               }
-       }
-       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_HASH_TOP(tdb->header.hash_size-1)) {
-               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];
-#if 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)
-               tdb->map_ptr = realloc(tdb->map_ptr, tdb->map_size);
-       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;
-       int maxloop;
-
-       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 */
-       maxloop = LOOP_MAX;
-       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;
-
-               maxloop--;
-               if (maxloop == 0) {
-                       TDB_LOG((tdb, 0, "tdb_allocate: maxloop reached; corrupt database!\n"));
-                       return TDB_ERRCODE(TDB_ERR_CORRUPT, 0);
-               }
-       }
-       /* 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;
-       int maxloop;
-
-       /* 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 */
-       maxloop = LOOP_MAX;
-       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;
-
-               maxloop--;
-               if (maxloop == 0) {
-                       TDB_LOG((tdb, 0, "tdb_find maxloop reached; corrupt database!\n"));
-                       return TDB_ERRCODE(TDB_ERR_CORRUPT, 0);
-               }
-       }
-       return TDB_ERRCODE(TDB_ERR_NOEXIST, 0);
-}
-
-/* If they do lockkeys, check that this hash is one they locked */
-static int tdb_keylocked(TDB_CONTEXT *tdb, u32 hash)
-{
-       u32 i;
-       if (!tdb->lockedkeys)
-               return 1;
-       for (i = 0; i < tdb->lockedkeys[0]; i++)
-               if (tdb->lockedkeys[i+1] == hash)
-                       return 1;
-       return TDB_ERRCODE(TDB_ERR_NOLOCK, 0);
-}
-
-/* As tdb_find, but if you succeed, keep the lock */
-static tdb_off tdb_find_lock(TDB_CONTEXT *tdb, TDB_DATA key, int locktype,
-                            struct list_struct *rec)
-{
-       u32 hash, rec_ptr;
-
-       hash = tdb_hash(&key);
-       if (!tdb_keylocked(tdb, hash))
-               return 0;
-       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(TDB_CONTEXT *tdb, TDB_DATA key, TDB_DATA dbuf)
-{
-       struct list_struct rec;
-       tdb_off rec_ptr;
-
-       /* find entry */
-       if (!(rec_ptr = tdb_find(tdb, key, tdb_hash(&key), &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;
-
-       /* find which hash bucket it is in */
-       if (!(rec_ptr = tdb_find_lock(tdb,key,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
-*/
-int tdb_exists(TDB_CONTEXT *tdb, TDB_DATA key)
-{
-       struct list_struct rec;
-       
-       if (tdb_find_lock(tdb, key, F_RDLCK, &rec) == 0)
-               return 0;
-       tdb_unlock(tdb, BUCKET(rec.full_hash), F_RDLCK);
-       return 1;
-}
-
-/* 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;
-       int maxloop;
-
-       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;
-
-       maxloop = LOOP_MAX;
-       for (last_ptr = 0; i != rec_ptr; last_ptr = i, i = lastrec.next) {
-               if (rec_read(tdb, i, &lastrec) == -1)
-                       return -1;
-
-               maxloop--;
-               if (maxloop == 0) {
-                       TDB_LOG((tdb, 0, "(tdb)do_delete: maxloop reached; corrupt database!\n"));
-                       return TDB_ERRCODE(TDB_ERR_CORRUPT, -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);
-
-       /* No traversal allows if you've called tdb_lockkeys() */
-       if (tdb->lockedkeys)
-               return TDB_ERRCODE(TDB_ERR_NOLOCK, -1);
-
-       /* Lock each chain from the start one. */
-       for (; tlock->hash < tdb->header.hash_size; tlock->hash++) {
-               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;
-                       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 *state)
-{
-       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, state)) {
-                       /* 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(tdb, 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 */
-int tdb_delete(TDB_CONTEXT *tdb, TDB_DATA key)
-{
-       tdb_off rec_ptr;
-       struct list_struct rec;
-       int ret;
-
-       if (!(rec_ptr = tdb_find_lock(tdb, key, 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;
-}
-
-/* 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(&key);
-       if (!tdb_keylocked(tdb, hash))
-               return -1;
-       if (tdb_lock(tdb, BUCKET(hash), F_WRLCK) == -1)
-               return -1;
-
-       /* check for it existing, on insert. */
-       if (flag == TDB_INSERT) {
-               if (tdb_exists(tdb, key)) {
-                       tdb->ecode = TDB_ERR_EXISTS;
-                       goto fail;
-               }
-       } else {
-               /* first try in-place update, on modify or replace. */
-               if (tdb_update(tdb, key, dbuf) == 0)
-                       goto out;
-               if (flag == TDB_MODIFY && tdb->ecode == TDB_ERR_NOEXIST)
-                       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(tdb, key);
-
-       /* 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);
-
-       /* now we're into insert / modify / replace of a record which
-        * we know could not be optimised by an in-place store (for
-        * various reasons).  */
-       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, TDB_DATA new_dbuf)
-{
-       struct list_struct rec;
-       tdb_off rec_ptr;
-
-       /* find entry */
-       if (!(rec_ptr = tdb_find(tdb, key, tdb_hash(&key), &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(&key);
-       if (!tdb_keylocked(tdb, hash))
-               return -1;
-       if (tdb_lock(tdb, BUCKET(hash), F_WRLCK) == -1)
-               return -1;
-
-       /* first try in-place. */
-       if (tdb_append_inplace(tdb, key, 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(tdb, key);
-
-       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;
-}
-
-/* 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);
-}
-
-
-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_CONTEXT *tdb;
-       struct stat st;
-       int rev = 0, locked;
-       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->lockedkeys = NULL;
-       tdb->flags = tdb_flags;
-       tdb->open_flags = open_flags;
-       tdb->log_fn = log_fn;
-       
-       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) */
-       }
-
-       /* 
-          Close file when execing another process.  
-          Prevents SELinux access errors.
-       */
-       set_cloexec_flag(tdb->fd, 1);
-
-       /* 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 ((locked = (tdb_brlock(tdb, ACTIVE_LOCK, F_WRLCK, F_SETLK, 0) == 0))
-           && (tdb_flags & TDB_CLEAR_IF_FIRST)) {
-               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,%lld) is already open in this process\n",
-                        name, major(st.st_dev), minor(st.st_dev), (unsigned long long)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;
-               }
-       }
-       /* 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);
-       SAFE_FREE(tdb->lockedkeys);
-
-       /* 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);
-       if (tdb->lockedkeys)
-               return TDB_ERRCODE(TDB_ERR_NOLOCK, -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);
-}
-
-int tdb_lockkeys(TDB_CONTEXT *tdb, u32 number, TDB_DATA keys[])
-{
-       u32 i, j, hash;
-
-       /* Can't lock more keys if already locked */
-       if (tdb->lockedkeys)
-               return TDB_ERRCODE(TDB_ERR_NOLOCK, -1);
-       if (!(tdb->lockedkeys = malloc(sizeof(u32) * (number+1))))
-               return TDB_ERRCODE(TDB_ERR_OOM, -1);
-       /* First number in array is # keys */
-       tdb->lockedkeys[0] = number;
-
-       /* Insertion sort by bucket */
-       for (i = 0; i < number; i++) {
-               hash = tdb_hash(&keys[i]);
-               for (j = 0; j < i && BUCKET(tdb->lockedkeys[j+1]) < BUCKET(hash); j++);
-                       memmove(&tdb->lockedkeys[j+2], &tdb->lockedkeys[j+1], sizeof(u32) * (i-j));
-               tdb->lockedkeys[j+1] = hash;
-       }
-       /* Finally, lock in order */
-       for (i = 0; i < number; i++)
-               if (tdb_lock(tdb, i, F_WRLCK))
-                       break;
-
-       /* If error, release locks we have... */
-       if (i < number) {
-               for ( j = 0; j < i; j++)
-                       tdb_unlock(tdb, j, F_WRLCK);
-               SAFE_FREE(tdb->lockedkeys);
-               return TDB_ERRCODE(TDB_ERR_NOLOCK, -1);
-       }
-       return 0;
-}
-
-/* Unlock the keys previously locked by tdb_lockkeys() */
-void tdb_unlockkeys(TDB_CONTEXT *tdb)
-{
-       u32 i;
-       if (!tdb->lockedkeys)
-               return;
-       for (i = 0; i < tdb->lockedkeys[0]; i++)
-               tdb_unlock(tdb, tdb->lockedkeys[i+1], F_WRLCK);
-       SAFE_FREE(tdb->lockedkeys);
-}
-
-/* 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(&key)), F_WRLCK);
-}
-
-int tdb_chainunlock(TDB_CONTEXT *tdb, TDB_DATA key)
-{
-       return tdb_unlock(tdb, BUCKET(tdb_hash(&key)), F_WRLCK);
-}
-
-int tdb_chainlock_read(TDB_CONTEXT *tdb, TDB_DATA key)
-{
-       return tdb_lock(tdb, BUCKET(tdb_hash(&key)), F_RDLCK);
-}
-
-int tdb_chainunlock_read(TDB_CONTEXT *tdb, TDB_DATA key)
-{
-       return tdb_unlock(tdb, BUCKET(tdb_hash(&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 is 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_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 (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);
-       if (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;
-       }
-
-       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 cac172a..0000000
--- a/tdb/tdb.h
+++ /dev/null
@@ -1,150 +0,0 @@
-#ifndef __TDB_H__
-#define __TDB_H__
-
-/* 
-   Unix SMB/CIFS implementation.
-   Samba database functions
-   Copyright (C) Andrew Tridgell 1999
-   
-   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., 675 Mass Ave, Cambridge, MA 02139, USA.
-*/
-
-#ifdef  __cplusplus
-extern "C" {
-#endif
-
-#define _KLIBC_HAS_ARCH_SIG_ATOMIC_T
-#include <signal.h>
-
-/* 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_NOEXIST, TDB_ERR_NOLOCK, TDB_ERR_LOCK_TIMEOUT };
-
-#ifndef u32
-#define u32 unsigned
-#endif
-
-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 */
-       u32 *lockedkeys; /* array of locked keys: first is #keys */
-       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 *, ...); /* logging function */
-       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 *, ...);
-
-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);
-
-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 *state);
-int tdb_exists(TDB_CONTEXT *tdb, TDB_DATA key);
-int tdb_lockkeys(TDB_CONTEXT *tdb, u32 number, TDB_DATA keys[]);
-void tdb_unlockkeys(TDB_CONTEXT *tdb);
-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);
-
-/* Debug functions. Not used in production. */
-void tdb_dump_all(TDB_CONTEXT *tdb);
-int tdb_printfreelist(TDB_CONTEXT *tdb);
-
-/* used only in tdbutil.c */
-int tdb_chainlock_read(TDB_CONTEXT *tdb, TDB_DATA key);
-int tdb_chainunlock_read(TDB_CONTEXT *tdb, TDB_DATA key);
-
-extern TDB_DATA tdb_null;
-
-#ifdef  __cplusplus
-}
-#endif
-
-#endif /* tdb.h */
diff --git a/tdb/tdb.magic b/tdb/tdb.magic
deleted file mode 100644 (file)
index f5619e7..0000000
+++ /dev/null
@@ -1,10 +0,0 @@
-# Magic file(1) information about tdb files.
-#
-# Install this into /etc/magic or the corresponding location for your
-# system, or pass as a -m argument to file(1).
-
-# You may use and redistribute this file without restriction.
-
-0      string  TDB\ file               TDB database
->32    lelong  =0x2601196D             version 6, little-endian
->>36   lelong  x                       hash size %d bytes
diff --git a/tdb/tdbback.c b/tdb/tdbback.c
deleted file mode 100644 (file)
index 744cfac..0000000
+++ /dev/null
@@ -1,201 +0,0 @@
-/* 
-   Unix SMB/CIFS implementation.
-   low level tdb backup and restore utility
-   Copyright (C) Andrew Tridgell              2002
-
-   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., 675 Mass Ave, Cambridge, MA 02139, USA.
-*/
-
-#include <errno.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <string.h>
-#include <fcntl.h>
-#include <time.h>
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <sys/time.h>
-#include <ctype.h>
-#include <signal.h>
-#include "tdb.h"
-
-static int failed;
-
-char *add_suffix(const char *name, const char *suffix)
-{
-       char *ret;
-       int len = strlen(name) + strlen(suffix) + 1;
-       ret = malloc(len);
-       if (!ret) {
-               fprintf(stderr,"Out of memory!\n");
-               exit(1);
-       }
-       strncpy(ret, name, len);
-       strncat(ret, suffix, len);
-       return ret;
-}
-
-static int copy_fn(TDB_CONTEXT *tdb, TDB_DATA key, TDB_DATA dbuf, void *state)
-{
-       TDB_CONTEXT *tdb_new = (TDB_CONTEXT *)state;
-
-       if (tdb_store(tdb_new, key, dbuf, TDB_INSERT) != 0) {
-               fprintf(stderr,"Failed to insert into %s\n", tdb_new->name);
-               failed = 1;
-               return 1;
-       }
-       return 0;
-}
-
-
-static int test_fn(TDB_CONTEXT *tdb, TDB_DATA key, TDB_DATA dbuf, void *state)
-{
-       return 0;
-}
-
-/*
-  carefully backup a tdb, validating the contents and
-  only doing the backup if its OK
-  this function is also used for restore
-*/
-int backup_tdb(const char *old_name, const char *new_name)
-{
-       TDB_CONTEXT *tdb;
-       TDB_CONTEXT *tdb_new;
-       char *tmp_name;
-       struct stat st;
-       int count1, count2;
-
-       tmp_name = add_suffix(new_name, ".tmp");
-
-       /* stat the old tdb to find its permissions */
-       if (stat(old_name, &st) != 0) {
-               perror(old_name);
-               return 1;
-       }
-
-       /* open the old tdb */
-       tdb = tdb_open(old_name, 0, 0, O_RDWR, 0);
-       if (!tdb) {
-               printf("Failed to open %s\n", old_name);
-               return 1;
-       }
-
-       /* create the new tdb */
-       unlink(tmp_name);
-       tdb_new = tdb_open(tmp_name, tdb->header.hash_size, 
-                          TDB_DEFAULT, O_RDWR|O_CREAT|O_EXCL, 
-                          st.st_mode & 0777);
-       if (!tdb_new) {
-               perror(tmp_name);
-               free(tmp_name);
-               return 1;
-       }
-
-       /* lock the old tdb */
-       if (tdb_lockall(tdb) != 0) {
-               fprintf(stderr,"Failed to lock %s\n", old_name);
-               tdb_close(tdb);
-               tdb_close(tdb_new);
-               unlink(tmp_name);
-               free(tmp_name);
-               return 1;
-       }
-
-       failed = 0;
-
-       /* traverse and copy */
-       count1 = tdb_traverse(tdb, copy_fn, (void *)tdb_new);
-       if (count1 < 0 || failed) {
-               fprintf(stderr,"failed to copy %s\n", old_name);
-               tdb_close(tdb);
-               tdb_close(tdb_new);
-               unlink(tmp_name);
-               free(tmp_name);
-               return 1;
-       }
-
-       /* close the old tdb */
-       tdb_close(tdb);
-
-       /* close the new tdb and re-open read-only */
-       tdb_close(tdb_new);
-       tdb_new = tdb_open(tmp_name, 0, TDB_DEFAULT, O_RDONLY, 0);
-       if (!tdb_new) {
-               fprintf(stderr,"failed to reopen %s\n", tmp_name);
-               unlink(tmp_name);
-               perror(tmp_name);
-               free(tmp_name);
-               return 1;
-       }
-       
-       /* traverse the new tdb to confirm */
-       count2 = tdb_traverse(tdb_new, test_fn, 0);
-       if (count2 != count1) {
-               fprintf(stderr,"failed to copy %s\n", old_name);
-               tdb_close(tdb_new);
-               unlink(tmp_name);
-               free(tmp_name);
-               return 1;
-       }
-
-       /* make sure the new tdb has reached stable storage */
-       fsync(tdb_new->fd);
-
-       /* close the new tdb and rename it to .bak */
-       tdb_close(tdb_new);
-       unlink(new_name);
-       if (rename(tmp_name, new_name) != 0) {
-               perror(new_name);
-               free(tmp_name);
-               return 1;
-       }
-
-       free(tmp_name);
-
-       return 0;
-}
-
-
-
-/*
-  verify a tdb and if it is corrupt then restore from *.bak
-*/
-int verify_tdb(const char *fname, const char *bak_name)
-{
-       TDB_CONTEXT *tdb;
-       int count = -1;
-
-       /* open the tdb */
-       tdb = tdb_open(fname, 0, 0, O_RDONLY, 0);
-
-       /* traverse the tdb, then close it */
-       if (tdb) {
-               count = tdb_traverse(tdb, test_fn, NULL);
-               tdb_close(tdb);
-       }
-
-       /* count is < 0 means an error */
-       if (count < 0) {
-               printf("restoring %s\n", fname);
-               return backup_tdb(bak_name, fname);
-       }
-
-       printf("%s : %d records\n", fname, count);
-
-       return 0;
-}
diff --git a/tdb/tdbback.h b/tdb/tdbback.h
deleted file mode 100644 (file)
index 7ebeaa4..0000000
+++ /dev/null
@@ -1,23 +0,0 @@
-/* 
-   Unix SMB/CIFS implementation.
-   low level tdb backup and restore utility
-   Copyright (C) Andrew Tridgell              2002
-
-   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., 675 Mass Ave, Cambridge, MA 02139, USA.
-*/
-
-char *add_suffix(const char *name, const char *suffix);
-int backup_tdb(const char *old_name, const char *new_name);
-int verify_tdb(const char *fname, const char *bak_name);
diff --git a/tdb/tdbbackup.c b/tdb/tdbbackup.c
deleted file mode 100644 (file)
index 0eaf6b6..0000000
+++ /dev/null
@@ -1,137 +0,0 @@
-/* 
-   Unix SMB/CIFS implementation.
-   low level tdb backup and restore utility
-   Copyright (C) Andrew Tridgell              2002
-
-   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., 675 Mass Ave, Cambridge, MA 02139, USA.
-*/
-
-/*
-
-  This program is meant for backup/restore of tdb databases. Typical usage would be:
-     tdbbackup *.tdb
-  when Samba shuts down cleanly, which will make a backup of all the local databases
-  to *.bak files. Then on Samba startup you would use:
-     tdbbackup -v *.tdb
-  and this will check the databases for corruption and if corruption is detected then
-  the backup will be restored.
-
-  You may also like to do a backup on a regular basis while Samba is
-  running, perhaps using cron.
-
-  The reason this program is needed is to cope with power failures
-  while Samba is running. A power failure could lead to database
-  corruption and Samba will then not start correctly.
-
-  Note that many of the databases in Samba are transient and thus
-  don't need to be backed up, so you can optimise the above a little
-  by only running the backup on the critical databases.
-
- */
-
-#include <errno.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <string.h>
-#include <fcntl.h>
-#include <time.h>
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <sys/time.h>
-#include <ctype.h>
-#include <signal.h>
-#include "tdb.h"
-#include "tdbback.h"
-
-/*
-  see if one file is newer than another
-*/
-static int file_newer(const char *fname1, const char *fname2)
-{
-       struct stat st1, st2;
-       if (stat(fname1, &st1) != 0) {
-               return 0;
-       }
-       if (stat(fname2, &st2) != 0) {
-               return 1;
-       }
-       return (st1.st_mtime > st2.st_mtime);
-}
-
-static void usage(void)
-{
-       printf("Usage: tdbbackup [options] <fname...>\n\n");
-       printf("   -h            this help message\n");
-       printf("   -s suffix     set the backup suffix\n");
-       printf("   -v            verify mode (restore if corrupt)\n");
-}
-               
-
- int main(int argc, char *argv[])
-{
-       int i;
-       int ret = 0;
-       int c;
-       int verify = 0;
-       const char *suffix = ".bak";
-       extern int optind;
-       extern char *optarg;
-
-       while ((c = getopt(argc, argv, "vhs:")) != -1) {
-               switch (c) {
-               case 'h':
-                       usage();
-                       exit(0);
-               case 'v':
-                       verify = 1;
-                       break;
-               case 's':
-                       suffix = optarg;
-                       break;
-               }
-       }
-
-       argc -= optind;
-       argv += optind;
-
-       if (argc < 1) {
-               usage();
-               exit(1);
-       }
-
-       for (i=0; i<argc; i++) {
-               const char *fname = argv[i];
-               char *bak_name;
-
-               bak_name = add_suffix(fname, suffix);
-
-               if (verify) {
-                       if (verify_tdb(fname, bak_name) != 0) {
-                               ret = 1;
-                       }
-               } else {
-                       if (file_newer(fname, bak_name) &&
-                           backup_tdb(fname, bak_name) != 0) {
-                               ret = 1;
-                       }
-               }
-
-               free(bak_name);
-       }
-
-       return ret;
-}
diff --git a/tdb/tdbdump.c b/tdb/tdbdump.c
deleted file mode 100644 (file)
index 9c1dc27..0000000
+++ /dev/null
@@ -1,89 +0,0 @@
-/* 
-   Unix SMB/CIFS implementation.
-   simple tdb dump util
-   Copyright (C) Andrew Tridgell              2001
-
-   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., 675 Mass Ave, Cambridge, MA 02139, USA.
-*/
-
-#include <errno.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <string.h>
-#include <fcntl.h>
-#include <time.h>
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <sys/time.h>
-#include <ctype.h>
-#include <signal.h>
-#include "tdb.h"
-
-static void print_data(TDB_DATA d)
-{
-       unsigned char *p = d.dptr;
-       int len = d.dsize;
-       while (len--) {
-               if (isprint(*p) && !strchr("\"\\", *p)) {
-                       fputc(*p, stdout);
-               } else {
-                       printf("\\%02X", *p);
-               }
-               p++;
-       }
-}
-
-static int traverse_fn(TDB_CONTEXT *tdb, TDB_DATA key, TDB_DATA dbuf, void *state)
-{
-       printf("{\n");
-       printf("key = \"");
-       print_data(key);
-       printf("\"\n");
-       printf("data = \"");
-       print_data(dbuf);
-       printf("\"\n");
-       printf("}\n");
-       return 0;
-}
-
-static int dump_tdb(const char *fname)
-{
-       TDB_CONTEXT *tdb;
-       
-       tdb = tdb_open(fname, 0, 0, O_RDONLY, 0);
-       if (!tdb) {
-               printf("Failed to open %s\n", fname);
-               return 1;
-       }
-
-       tdb_traverse(tdb, traverse_fn, NULL);
-       return 0;
-}
-
- int main(int argc, char *argv[])
-{
-       char *fname;
-
-       if (argc < 2) {
-               printf("Usage: tdbdump <fname>\n");
-               exit(1);
-       }
-
-       fname = argv[1];
-
-       return dump_tdb(fname);
-}
diff --git a/tdb/tdbutil.c b/tdb/tdbutil.c
deleted file mode 100644 (file)
index b01dacd..0000000
+++ /dev/null
@@ -1,830 +0,0 @@
-/* 
-   Unix SMB/CIFS implementation.
-   tdb utility functions
-   Copyright (C) Andrew Tridgell 1992-1998
-   
-   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., 675 Mass Ave, Cambridge, MA 02139, USA.
-*/
-
-#include "includes.h"
-#include <fnmatch.h>
-
-/* these are little tdb utility functions that are meant to make
-   dealing with a tdb database a little less cumbersome in Samba */
-
-static SIG_ATOMIC_T gotalarm;
-
-/***************************************************************
- Signal function to tell us we timed out.
-****************************************************************/
-
-static void gotalarm_sig(void)
-{
-       gotalarm = 1;
-}
-
-/***************************************************************
- Make a TDB_DATA and keep the const warning in one place
-****************************************************************/
-
-static TDB_DATA make_tdb_data(const char *dptr, size_t dsize)
-{
-       TDB_DATA ret;
-       ret.dptr = dptr;
-       ret.dsize = dsize;
-       return ret;
-}
-
-/****************************************************************************
- Lock a chain with timeout (in seconds).
-****************************************************************************/
-
-static int tdb_chainlock_with_timeout_internal( TDB_CONTEXT *tdb, TDB_DATA key, unsigned int timeout, int rw_type)
-{
-       /* Allow tdb_chainlock to be interrupted by an alarm. */
-       int ret;
-       gotalarm = 0;
-       tdb_set_lock_alarm(&gotalarm);
-
-       if (timeout) {
-               CatchSignal(SIGALRM, SIGNAL_CAST gotalarm_sig);
-               alarm(timeout);
-       }
-
-       if (rw_type == F_RDLCK)
-               ret = tdb_chainlock_read(tdb, key);
-       else
-               ret = tdb_chainlock(tdb, key);
-
-       if (timeout) {
-               alarm(0);
-               CatchSignal(SIGALRM, SIGNAL_CAST SIG_IGN);
-               if (gotalarm) {
-                       DEBUG(0,("tdb_chainlock_with_timeout_internal: alarm (%u) timed out for key %s in tdb %s\n",
-                               timeout, key.dptr, tdb->name ));
-                       /* TODO: If we time out waiting for a lock, it might
-                        * be nice to use F_GETLK to get the pid of the
-                        * process currently holding the lock and print that
-                        * as part of the debugging message. -- mbp */
-                       return -1;
-               }
-       }
-
-       return ret;
-}
-
-/****************************************************************************
- Write lock a chain. Return -1 if timeout or lock failed.
-****************************************************************************/
-
-int tdb_chainlock_with_timeout( TDB_CONTEXT *tdb, TDB_DATA key, unsigned int timeout)
-{
-       return tdb_chainlock_with_timeout_internal(tdb, key, timeout, F_WRLCK);
-}
-
-/****************************************************************************
- Lock a chain by string. Return -1 if timeout or lock failed.
-****************************************************************************/
-
-int tdb_lock_bystring(TDB_CONTEXT *tdb, const char *keyval, unsigned int timeout)
-{
-       TDB_DATA key = make_tdb_data(keyval, strlen(keyval)+1);
-       
-       return tdb_chainlock_with_timeout_internal(tdb, key, timeout, F_WRLCK);
-}
-
-/****************************************************************************
- Unlock a chain by string.
-****************************************************************************/
-
-void tdb_unlock_bystring(TDB_CONTEXT *tdb, const char *keyval)
-{
-       TDB_DATA key = make_tdb_data(keyval, strlen(keyval)+1);
-
-       tdb_chainunlock(tdb, key);
-}
-
-/****************************************************************************
- Read lock a chain by string. Return -1 if timeout or lock failed.
-****************************************************************************/
-
-int tdb_read_lock_bystring(TDB_CONTEXT *tdb, const char *keyval, unsigned int timeout)
-{
-       TDB_DATA key = make_tdb_data(keyval, strlen(keyval)+1);
-       
-       return tdb_chainlock_with_timeout_internal(tdb, key, timeout, F_RDLCK);
-}
-
-/****************************************************************************
- Read unlock a chain by string.
-****************************************************************************/
-
-void tdb_read_unlock_bystring(TDB_CONTEXT *tdb, const char *keyval)
-{
-       TDB_DATA key = make_tdb_data(keyval, strlen(keyval)+1);
-       
-       tdb_chainunlock_read(tdb, key);
-}
-
-
-/****************************************************************************
- Fetch a int32 value by a arbitrary blob key, return -1 if not found.
- Output is int32 in native byte order.
-****************************************************************************/
-
-int32 tdb_fetch_int32_byblob(TDB_CONTEXT *tdb, const char *keyval, size_t len)
-{
-       TDB_DATA key = make_tdb_data(keyval, len);
-       TDB_DATA data;
-       int32 ret;
-
-       data = tdb_fetch(tdb, key);
-       if (!data.dptr || data.dsize != sizeof(int32)) {
-               SAFE_FREE(data.dptr);
-               return -1;
-       }
-
-       ret = IVAL(data.dptr,0);
-       SAFE_FREE(data.dptr);
-       return ret;
-}
-
-/****************************************************************************
- Fetch a int32 value by string key, return -1 if not found.
- Output is int32 in native byte order.
-****************************************************************************/
-
-int32 tdb_fetch_int32(TDB_CONTEXT *tdb, const char *keystr)
-{
-       return tdb_fetch_int32_byblob(tdb, keystr, strlen(keystr) + 1);
-}
-
-/****************************************************************************
- Store a int32 value by an arbitary blob key, return 0 on success, -1 on failure.
- Input is int32 in native byte order. Output in tdb is in little-endian.
-****************************************************************************/
-
-int tdb_store_int32_byblob(TDB_CONTEXT *tdb, const char *keystr, size_t len, int32 v)
-{
-       TDB_DATA key = make_tdb_data(keystr, len);
-       TDB_DATA data;
-       int32 v_store;
-
-       SIVAL(&v_store,0,v);
-       data.dptr = (void *)&v_store;
-       data.dsize = sizeof(int32);
-
-       return tdb_store(tdb, key, data, TDB_REPLACE);
-}
-
-/****************************************************************************
- Store a int32 value by string key, return 0 on success, -1 on failure.
- Input is int32 in native byte order. Output in tdb is in little-endian.
-****************************************************************************/
-
-int tdb_store_int32(TDB_CONTEXT *tdb, const char *keystr, int32 v)
-{
-       return tdb_store_int32_byblob(tdb, keystr, strlen(keystr) + 1, v);
-}
-
-/****************************************************************************
- Fetch a uint32 value by a arbitrary blob key, return -1 if not found.
- Output is uint32 in native byte order.
-****************************************************************************/
-
-BOOL tdb_fetch_uint32_byblob(TDB_CONTEXT *tdb, const char *keyval, size_t len, uint32 *value)
-{
-       TDB_DATA key = make_tdb_data(keyval, len);
-       TDB_DATA data;
-
-       data = tdb_fetch(tdb, key);
-       if (!data.dptr || data.dsize != sizeof(uint32)) {
-               SAFE_FREE(data.dptr);
-               return False;
-       }
-
-       *value = IVAL(data.dptr,0);
-       SAFE_FREE(data.dptr);
-       return True;
-}
-
-/****************************************************************************
- Fetch a uint32 value by string key, return -1 if not found.
- Output is uint32 in native byte order.
-****************************************************************************/
-
-BOOL tdb_fetch_uint32(TDB_CONTEXT *tdb, const char *keystr, uint32 *value)
-{
-       return tdb_fetch_uint32_byblob(tdb, keystr, strlen(keystr) + 1, value);
-}
-
-/****************************************************************************
- Store a uint32 value by an arbitary blob key, return 0 on success, -1 on failure.
- Input is uint32 in native byte order. Output in tdb is in little-endian.
-****************************************************************************/
-
-BOOL tdb_store_uint32_byblob(TDB_CONTEXT *tdb, const char *keystr, size_t len, uint32 value)
-{
-       TDB_DATA key = make_tdb_data(keystr, len);
-       TDB_DATA data;
-       uint32 v_store;
-       BOOL ret = True;
-
-       SIVAL(&v_store, 0, value);
-       data.dptr = (void *)&v_store;
-       data.dsize = sizeof(uint32);
-
-       if (tdb_store(tdb, key, data, TDB_REPLACE) == -1)
-               ret = False;
-
-       return ret;
-}
-
-/****************************************************************************
- Store a uint32 value by string key, return 0 on success, -1 on failure.
- Input is uint32 in native byte order. Output in tdb is in little-endian.
-****************************************************************************/
-
-BOOL tdb_store_uint32(TDB_CONTEXT *tdb, const char *keystr, uint32 value)
-{
-       return tdb_store_uint32_byblob(tdb, keystr, strlen(keystr) + 1, value);
-}
-/****************************************************************************
- Store a buffer by a null terminated string key.  Return 0 on success, -1
- on failure.
-****************************************************************************/
-
-int tdb_store_bystring(TDB_CONTEXT *tdb, const char *keystr, TDB_DATA data, int flags)
-{
-       TDB_DATA key = make_tdb_data(keystr, strlen(keystr)+1);
-       
-       return tdb_store(tdb, key, data, flags);
-}
-
-/****************************************************************************
- Fetch a buffer using a null terminated string key.  Don't forget to call
- free() on the result dptr.
-****************************************************************************/
-
-TDB_DATA tdb_fetch_bystring(TDB_CONTEXT *tdb, const char *keystr)
-{
-       TDB_DATA key = make_tdb_data(keystr, strlen(keystr)+1);
-
-       return tdb_fetch(tdb, key);
-}
-
-/****************************************************************************
- Delete an entry using a null terminated string key. 
-****************************************************************************/
-
-int tdb_delete_bystring(TDB_CONTEXT *tdb, const char *keystr)
-{
-       TDB_DATA key = make_tdb_data(keystr, strlen(keystr)+1);
-
-       return tdb_delete(tdb, key);
-}
-
-/****************************************************************************
- Atomic integer change. Returns old value. To create, set initial value in *oldval. 
-****************************************************************************/
-
-int32 tdb_change_int32_atomic(TDB_CONTEXT *tdb, const char *keystr, int32 *oldval, int32 change_val)
-{
-       int32 val;
-       int32 ret = -1;
-
-       if (tdb_lock_bystring(tdb, keystr,0) == -1)
-               return -1;
-
-       if ((val = tdb_fetch_int32(tdb, keystr)) == -1) {
-               /* The lookup failed */
-               if (tdb_error(tdb) != TDB_ERR_NOEXIST) {
-                       /* but not because it didn't exist */
-                       goto err_out;
-               }
-               
-               /* Start with 'old' value */
-               val = *oldval;
-
-       } else {
-               /* It worked, set return value (oldval) to tdb data */
-               *oldval = val;
-       }
-
-       /* Increment value for storage and return next time */
-       val += change_val;
-               
-       if (tdb_store_int32(tdb, keystr, val) == -1)
-               goto err_out;
-
-       ret = 0;
-
-  err_out:
-
-       tdb_unlock_bystring(tdb, keystr);
-       return ret;
-}
-
-/****************************************************************************
- Atomic unsigned integer change. Returns old value. To create, set initial value in *oldval. 
-****************************************************************************/
-
-BOOL tdb_change_uint32_atomic(TDB_CONTEXT *tdb, const char *keystr, uint32 *oldval, uint32 change_val)
-{
-       uint32 val;
-       BOOL ret = False;
-
-       if (tdb_lock_bystring(tdb, keystr,0) == -1)
-               return False;
-
-       if (!tdb_fetch_uint32(tdb, keystr, &val)) {
-               /* It failed */
-               if (tdb_error(tdb) != TDB_ERR_NOEXIST) { 
-                       /* and not because it didn't exist */
-                       goto err_out;
-               }
-
-               /* Start with 'old' value */
-               val = *oldval;
-
-       } else {
-               /* it worked, set return value (oldval) to tdb data */
-               *oldval = val;
-
-       }
-
-       /* get a new value to store */
-       val += change_val;
-               
-       if (!tdb_store_uint32(tdb, keystr, val))
-               goto err_out;
-
-       ret = True;
-
-  err_out:
-
-       tdb_unlock_bystring(tdb, keystr);
-       return ret;
-}
-
-/****************************************************************************
- Useful pair of routines for packing/unpacking data consisting of
- integers and strings.
-****************************************************************************/
-
-size_t tdb_pack(char *buf, int bufsize, const char *fmt, ...)
-{
-       va_list ap;
-       uint8 bt;
-       uint16 w;
-       uint32 d;
-       int i;
-       void *p;
-       int len;
-       char *s;
-       char c;
-       char *buf0 = buf;
-       const char *fmt0 = fmt;
-       int bufsize0 = bufsize;
-
-       va_start(ap, fmt);
-
-       while (*fmt) {
-               switch ((c = *fmt++)) {
-               case 'b': /* unsigned 8-bit integer */
-                       len = 1;
-                       bt = (uint8)va_arg(ap, int);
-                       if (bufsize && bufsize >= len)
-                               SSVAL(buf, 0, bt);
-                       break;
-               case 'w': /* unsigned 16-bit integer */
-                       len = 2;
-                       w = (uint16)va_arg(ap, int);
-                       if (bufsize && bufsize >= len)
-                               SSVAL(buf, 0, w);
-                       break;
-               case 'd': /* signed 32-bit integer (standard int in most systems) */
-                       len = 4;
-                       d = va_arg(ap, uint32);
-                       if (bufsize && bufsize >= len)
-                               SIVAL(buf, 0, d);
-                       break;
-               case 'p': /* pointer */
-                       len = 4;
-                       p = va_arg(ap, void *);
-                       d = p?1:0;
-                       if (bufsize && bufsize >= len)
-                               SIVAL(buf, 0, d);
-                       break;
-               case 'P': /* null-terminated string */
-                       s = va_arg(ap,char *);
-                       w = strlen(s);
-                       len = w + 1;
-                       if (bufsize && bufsize >= len)
-                               memcpy(buf, s, len);
-                       break;
-               case 'f': /* null-terminated string */
-                       s = va_arg(ap,char *);
-                       w = strlen(s);
-                       len = w + 1;
-                       if (bufsize && bufsize >= len)
-                               memcpy(buf, s, len);
-                       break;
-               case 'B': /* fixed-length string */
-                       i = va_arg(ap, int);
-                       s = va_arg(ap, char *);
-                       len = 4+i;
-                       if (bufsize && bufsize >= len) {
-                               SIVAL(buf, 0, i);
-                               memcpy(buf+4, s, i);
-                       }
-                       break;
-               default:
-                       DEBUG(0,("Unknown tdb_pack format %c in %s\n", 
-                                c, fmt));
-                       len = 0;
-                       break;
-               }
-
-               buf += len;
-               if (bufsize)
-                       bufsize -= len;
-               if (bufsize < 0)
-                       bufsize = 0;
-       }
-
-       va_end(ap);
-
-       DEBUG(18,("tdb_pack(%s, %d) -> %d\n", 
-                fmt0, bufsize0, (int)PTR_DIFF(buf, buf0)));
-       
-       return PTR_DIFF(buf, buf0);
-}
-
-/****************************************************************************
- Useful pair of routines for packing/unpacking data consisting of
- integers and strings.
-****************************************************************************/
-
-int tdb_unpack(char *buf, int bufsize, const char *fmt, ...)
-{
-       va_list ap;
-       uint8 *bt;
-       uint16 *w;
-       uint32 *d;
-       int len;
-       int *i;
-       void **p;
-       char *s, **b;
-       char c;
-       char *buf0 = buf;
-       const char *fmt0 = fmt;
-       int bufsize0 = bufsize;
-
-       va_start(ap, fmt);
-       
-       while (*fmt) {
-               switch ((c=*fmt++)) {
-               case 'b':
-                       len = 1;
-                       bt = va_arg(ap, uint8 *);
-                       if (bufsize < len)
-                               goto no_space;
-                       *bt = SVAL(buf, 0);
-                       break;
-               case 'w':
-                       len = 2;
-                       w = va_arg(ap, uint16 *);
-                       if (bufsize < len)
-                               goto no_space;
-                       *w = SVAL(buf, 0);
-                       break;
-               case 'd':
-                       len = 4;
-                       d = va_arg(ap, uint32 *);
-                       if (bufsize < len)
-                               goto no_space;
-                       *d = IVAL(buf, 0);
-                       break;
-               case 'p':
-                       len = 4;
-                       p = va_arg(ap, void **);
-                       if (bufsize < len)
-                               goto no_space;
-                       *p = (void *)IVAL(buf, 0);
-                       break;
-               case 'P':
-                       s = va_arg(ap,char *);
-                       len = strlen(buf) + 1;
-                       if (bufsize < len || len > sizeof(pstring))
-                               goto no_space;
-                       memcpy(s, buf, len);
-                       break;
-               case 'f':
-                       s = va_arg(ap,char *);
-                       len = strlen(buf) + 1;
-                       if (bufsize < len || len > sizeof(fstring))
-                               goto no_space;
-                       memcpy(s, buf, len);
-                       break;
-               case 'B':
-                       i = va_arg(ap, int *);
-                       b = va_arg(ap, char **);
-                       len = 4;
-                       if (bufsize < len)
-                               goto no_space;
-                       *i = IVAL(buf, 0);
-                       if (! *i) {
-                               *b = NULL;
-                               break;
-                       }
-                       len += *i;
-                       if (bufsize < len)
-                               goto no_space;
-                       *b = (char *)malloc(*i);
-                       if (! *b)
-                               goto no_space;
-                       memcpy(*b, buf+4, *i);
-                       break;
-               default:
-                       DEBUG(0,("Unknown tdb_unpack format %c in %s\n", 
-                                c, fmt));
-
-                       len = 0;
-                       break;
-               }
-
-               buf += len;
-               bufsize -= len;
-       }
-
-       va_end(ap);
-
-       DEBUG(18,("tdb_unpack(%s, %d) -> %d\n", 
-                fmt0, bufsize0, (int)PTR_DIFF(buf, buf0)));
-
-       return PTR_DIFF(buf, buf0);
-
- no_space:
-       return -1;
-}
-
-
-/**
- * Pack SID passed by pointer
- *
- * @param pack_buf pointer to buffer which is to be filled with packed data
- * @param bufsize size of packing buffer
- * @param sid pointer to sid to be packed
- *
- * @return length of the packed representation of the whole structure
- **/
-size_t tdb_sid_pack(char* pack_buf, int bufsize, DOM_SID* sid)
-{
-       int idx;
-       size_t len = 0;
-       
-       if (!sid || !pack_buf) return -1;
-       
-       len += tdb_pack(pack_buf + len, bufsize - len, "bb", sid->sid_rev_num,
-                       sid->num_auths);
-       
-       for (idx = 0; idx < 6; idx++) {
-               len += tdb_pack(pack_buf + len, bufsize - len, "b", sid->id_auth[idx]);
-       }
-       
-       for (idx = 0; idx < MAXSUBAUTHS; idx++) {
-               len += tdb_pack(pack_buf + len, bufsize - len, "d", sid->sub_auths[idx]);
-       }
-       
-       return len;
-}
-
-
-/**
- * Unpack SID into a pointer
- *
- * @param pack_buf pointer to buffer with packed representation
- * @param bufsize size of the buffer
- * @param sid pointer to sid structure to be filled with unpacked data
- *
- * @return size of structure unpacked from buffer
- **/
-size_t tdb_sid_unpack(char* pack_buf, int bufsize, DOM_SID* sid)
-{
-       int idx, len = 0;
-       
-       if (!sid || !pack_buf) return -1;
-
-       len += tdb_unpack(pack_buf + len, bufsize - len, "bb",
-                         &sid->sid_rev_num, &sid->num_auths);
-                         
-       for (idx = 0; idx < 6; idx++) {
-               len += tdb_unpack(pack_buf + len, bufsize - len, "b", &sid->id_auth[idx]);
-       }
-       
-       for (idx = 0; idx < MAXSUBAUTHS; idx++) {
-               len += tdb_unpack(pack_buf + len, bufsize - len, "d", &sid->sub_auths[idx]);
-       }
-       
-       return len;
-}
-
-
-/**
- * Pack TRUSTED_DOM_PASS passed by pointer
- *
- * @param pack_buf pointer to buffer which is to be filled with packed data
- * @param bufsize size of the buffer
- * @param pass pointer to trusted domain password to be packed
- *
- * @return length of the packed representation of the whole structure
- **/
-size_t tdb_trusted_dom_pass_pack(char* pack_buf, int bufsize, TRUSTED_DOM_PASS* pass)
-{
-       int idx, len = 0;
-       
-       if (!pack_buf || !pass) return -1;
-       
-       /* packing unicode domain name and password */
-       len += tdb_pack(pack_buf + len, bufsize - len, "d", pass->uni_name_len);
-       
-       for (idx = 0; idx < 32; idx++)
-               len +=  tdb_pack(pack_buf + len, bufsize - len, "w", pass->uni_name[idx]);
-       
-       len += tdb_pack(pack_buf + len, bufsize - len, "dPd", pass->pass_len,
-                            pass->pass, pass->mod_time);
-
-       /* packing SID structure */
-       len += tdb_sid_pack(pack_buf + len, bufsize - len, &pass->domain_sid);
-
-       return len;
-}
-
-
-/**
- * Unpack TRUSTED_DOM_PASS passed by pointer
- *
- * @param pack_buf pointer to buffer with packed representation
- * @param bufsize size of the buffer
- * @param pass pointer to trusted domain password to be filled with unpacked data
- *
- * @return size of structure unpacked from buffer
- **/
-size_t tdb_trusted_dom_pass_unpack(char* pack_buf, int bufsize, TRUSTED_DOM_PASS* pass)
-{
-       int idx, len = 0;
-       
-       if (!pack_buf || !pass) return -1;
-
-       /* unpack unicode domain name and plaintext password */
-       len += tdb_unpack(pack_buf, bufsize - len, "d", &pass->uni_name_len);
-       
-       for (idx = 0; idx < 32; idx++)
-               len +=  tdb_unpack(pack_buf + len, bufsize - len, "w", &pass->uni_name[idx]);
-
-       len += tdb_unpack(pack_buf + len, bufsize - len, "dPd", &pass->pass_len, &pass->pass,
-                         &pass->mod_time);
-       
-       /* unpack domain sid */
-       len += tdb_sid_unpack(pack_buf + len, bufsize - len, &pass->domain_sid);
-       
-       return len;     
-}
-
-
-/****************************************************************************
- Log tdb messages via DEBUG().
-****************************************************************************/
-
-static void tdb_log(TDB_CONTEXT *tdb, int level, const char *format, ...)
-{
-       va_list ap;
-       char *ptr = NULL;
-
-       va_start(ap, format);
-       vasprintf(&ptr, format, ap);
-       va_end(ap);
-       
-       if (!ptr || !*ptr)
-               return;
-
-       DEBUG(level, ("tdb(%s): %s", tdb->name ? tdb->name : "unnamed", ptr));
-       SAFE_FREE(ptr);
-}
-
-/****************************************************************************
- Like tdb_open() but also setup a logging function that redirects to
- the samba DEBUG() system.
-****************************************************************************/
-
-TDB_CONTEXT *tdb_open_log(const char *name, int hash_size, int tdb_flags,
-                         int open_flags, mode_t mode)
-{
-       TDB_CONTEXT *tdb;
-
-       if (!lp_use_mmap())
-               tdb_flags |= TDB_NOMMAP;
-
-       tdb = tdb_open_ex(name, hash_size, tdb_flags, 
-                                   open_flags, mode, tdb_log);
-       if (!tdb)
-               return NULL;
-
-       return tdb;
-}
-
-
-/****************************************************************************
- Allow tdb_delete to be used as a tdb_traversal_fn.
-****************************************************************************/
-
-int tdb_traverse_delete_fn(TDB_CONTEXT *the_tdb, TDB_DATA key, TDB_DATA dbuf,
-                     void *state)
-{
-    return tdb_delete(the_tdb, key);
-}
-
-
-
-/**
- * Search across the whole tdb for keys that match the given pattern
- * return the result as a list of keys
- *
- * @param tdb pointer to opened tdb file context
- * @param pattern searching pattern used by fnmatch(3) functions
- *
- * @return list of keys found by looking up with given pattern
- **/
-TDB_LIST_NODE *tdb_search_keys(TDB_CONTEXT *tdb, const char* pattern)
-{
-       TDB_DATA key, next;
-       TDB_LIST_NODE *list = NULL;
-       TDB_LIST_NODE *rec = NULL;
-       TDB_LIST_NODE *tmp = NULL;
-       
-       for (key = tdb_firstkey(tdb); key.dptr; key = next) {
-               /* duplicate key string to ensure null-termination */
-               char *key_str = (char*) strndup(key.dptr, key.dsize);
-               if (!key_str) {
-                       DEBUG(0, ("tdb_search_keys: strndup() failed!\n"));
-                       smb_panic("strndup failed!\n");
-               }
-               
-               DEBUG(18, ("checking %s for match to pattern %s\n", key_str, pattern));
-               
-               next = tdb_nextkey(tdb, key);
-
-               /* do the pattern checking */
-               if (fnmatch(pattern, key_str, 0) == 0) {
-                       rec = (TDB_LIST_NODE*) malloc(sizeof(*rec));
-                       ZERO_STRUCTP(rec);
-
-                       rec->node_key = key;
-       
-                       DLIST_ADD_END(list, rec, tmp);
-               
-                       DEBUG(18, ("checking %s matched pattern %s\n", key_str, pattern));
-               } else {
-                       free(key.dptr);
-               }
-               
-               /* free duplicated key string */
-               free(key_str);
-       }
-       
-       return list;
-
-};
-
-
-/**
- * Free the list returned by tdb_search_keys
- *
- * @param node list of results found by tdb_search_keys
- **/
-void tdb_search_list_free(TDB_LIST_NODE* node)
-{
-       TDB_LIST_NODE *next_node;
-       
-       while (node) {
-               next_node = node->next;
-               SAFE_FREE(node->node_key.dptr);
-               SAFE_FREE(node);
-               node = next_node;
-       };
-};
-
-
diff --git a/tdb/tdbutil.h b/tdb/tdbutil.h
deleted file mode 100644 (file)
index 0147344..0000000
+++ /dev/null
@@ -1,37 +0,0 @@
-/* 
-   Unix SMB/CIFS implementation.
-   tdb utility functions
-   Copyright (C) Andrew Tridgell 1999
-   
-   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., 675 Mass Ave, Cambridge, MA 02139, USA.
-*/
-
-#ifndef __TDBUTIL_H__
-#define __TDBUTIL_H__
-
-
-/* single node of a list returned by tdb_search_keys */
-typedef struct keys_node 
-{
-       struct keys_node *prev, *next;
-       TDB_DATA node_key;
-} TDB_LIST_NODE;
-
-
-TDB_LIST_NODE *tdb_search_keys(TDB_CONTEXT*, const char*);
-void tdb_search_list_free(TDB_LIST_NODE*);
-
-
-#endif /* __TDBUTIL_H__ */
index 007a0be..6e4c206 100644 (file)
@@ -14,7 +14,7 @@ EOF
 
 cat > $CONFIG << EOF
 udev_root="$PWD/udev/"
-udev_db="$PWD/udev/.udev.tdb"
+udev_db="$PWD/udev/.udevdb"
 udev_rules="$PWD/$RULES"
 udev_permissions="$PWD/udev.permissions"
 EOF
index ca51e9a..d22a4d7 100644 (file)
@@ -13,7 +13,7 @@ EOF
 
 cat > $CONFIG << EOF
 udev_root="$PWD/udev/"
-udev_db="$PWD/udev/.udev.tdb"
+udev_db="$PWD/udev/.udevdb"
 udev_rules="$PWD/$RULES"
 udev_permissions="$PWD/udev.permissions"
 udev_log="true"
index b99a4ac..fbb7309 100644 (file)
@@ -14,7 +14,7 @@ EOF
 
 cat > $CONFIG << EOF
 udev_root="$PWD/udev/"
-udev_db="$PWD/udev/.udev.tdb"
+udev_db="$PWD/udev/.udevdb"
 udev_rules="$PWD/$RULES"
 udev_permissions="$PWD/udev.permissions"
 EOF
index 7ffc7b1..c2b5ec6 100644 (file)
@@ -13,7 +13,7 @@ EOF
 
 cat > $CONFIG << EOF
 udev_root="$PWD/udev/"
-udev_db="$PWD/udev/.udev.tdb"
+udev_db="$PWD/udev/.udevdb"
 udev_rules="$PWD/$RULES"
 udev_permissions="$PWD/udev.permissions"
 EOF
index 56a6847..ec0dea4 100644 (file)
@@ -13,7 +13,7 @@ EOF
 
 cat > $CONFIG << EOF
 udev_root="$PWD/udev/"
-udev_db="$PWD/udev/.udev.tdb"
+udev_db="$PWD/udev/.udevdb"
 udev_rules="$PWD/$RULES"
 udev_permissions="$PWD/udev.permissions"
 EOF
index 10215b0..9445b72 100644 (file)
@@ -13,7 +13,7 @@ EOF
 
 cat > $CONFIG << EOF
 udev_root="$PWD/udev/"
-udev_db="$PWD/udev/.udev.tdb"
+udev_db="$PWD/udev/.udevdb"
 udev_rules="$PWD/$RULES"
 udev_permissions="$PWD/udev.permissions"
 EOF
index 18b2549..77333a9 100644 (file)
@@ -13,7 +13,7 @@ EOF
 
 cat > $CONFIG << EOF
 udev_root="$PWD/udev/"
-udev_db="$PWD/udev/.udev.tdb"
+udev_db="$PWD/udev/.udevdb"
 udev_rules="$PWD/$RULES"
 udev_permissions="$PWD/udev.permissions"
 EOF
index e8ce0b4..2ba63fe 100644 (file)
@@ -30,7 +30,7 @@ my $PWD = $ENV{PWD};
 my $sysfs     = "sys/";
 my $udev_bin  = "../udev";
 my $udev_root = "udev-root/"; # !!! directory will be removed !!!
-my $udev_db   = ".udev.tdb";
+my $udev_db   = ".udevdb";
 my $perm      = "udev.permissions";
 my $main_conf = "udev-test.conf";
 my $conf_tmp  = "udev-test.rules";
@@ -1268,7 +1268,7 @@ sub run_test {
        }
 
        if (defined($config->{option}) && $config->{option} eq "clear") {
-               unlink($udev_db);
+               system("rm -rf $udev_db");
                system("rm -rf $udev_root");
                mkdir($udev_root) || die "unable to create udev_root: $udev_root\n";
        }
@@ -1319,7 +1319,7 @@ if ($ARGV[0]) {
 print "$error errors occured\n\n";
 
 # cleanup
-unlink($udev_db);
+system("rm -rf $udev_db");
 system("rm -rf $udev_root");
 unlink($conf_tmp);
 unlink($main_conf);
index a7f0bf0..168842d 100644 (file)
--- a/udev.8.in
+++ b/udev.8.in
@@ -74,7 +74,7 @@ value is
 .TP
 .B udev_db
 The name and location of the udev database. The default value is
-.IR @udevdir@/.udev.tdb .
+.IR @udevdir@/.udevdb .
 .TP
 .B udev_rules
 The name of the udev rules file or directory to look for files with the suffix
@@ -117,7 +117,7 @@ file. The default value is
 udev_root="/udev"
 
 # udev_db - The name and location of the udev database
-udev_db="/udev/.udev.tdb"
+udev_db="/udev/.udevdb"
 
 # udev_rules - The name of the udev rules file or directory to look
                for files with the suffix .rules
diff --git a/udev.c b/udev.c
index 7809060..d8cb436 100644 (file)
--- a/udev.c
+++ b/udev.c
@@ -38,8 +38,6 @@
 #include "namedev.h"
 #include "udevdb.h"
 
-/* timeout flag for udevdb */
-extern sig_atomic_t gotalarm;
 
 /* global variables */
 char **main_argv;
@@ -64,8 +62,7 @@ static void asmlinkage sig_handler(int signum)
 {
        switch (signum) {
                case SIGALRM:
-                       gotalarm = 1;
-                       break;
+                       exit(1);
                case SIGINT:
                case SIGTERM:
                        exit(20 + signum);
@@ -153,10 +150,6 @@ int main(int argc, char *argv[], char *envp[])
        /* trigger timout to interrupt blocking syscalls */
        alarm(ALARM_TIMEOUT);
 
-       /* initialize udev database */
-       if (udevdb_init(UDEVDB_DEFAULT) != 0)
-               info("error: unable to initialize database, continuing without database");
-
        switch(act_type) {
        case UDEVSTART:
                dbg("udevstart");
@@ -196,8 +189,6 @@ int main(int argc, char *argv[], char *envp[])
                dev_d_execute(&udev);
        }
 
-       udevdb_exit();
-
 exit:
        logging_close();
        return retval;
diff --git a/udev.h b/udev.h
index e895433..1cf4ad7 100644 (file)
--- a/udev.h
+++ b/udev.h
 
 #define LINE_SIZE                      256
 
-/* length of public data to store in udevdb */
-#define UDEVICE_DB_LEN (offsetof(struct udevice, devpath))
-
 struct udevice {
+       char devpath[DEVPATH_SIZE];
+       char subsystem[SUBSYSTEM_SIZE];
        char name[NAME_SIZE];
        char owner[OWNER_SIZE];
        char group[GROUP_SIZE];
        char type;
        int major;
        int minor;
-       unsigned int mode;      /* not mode_t due to conflicting definitions in different libcs */
+       mode_t mode;
        char symlink[NAME_SIZE];
        int partitions;
        int config_line;
        char config_file[NAME_SIZE];
        long config_uptime;
-
-       /* private data, not stored in udevdb */
-       char devpath[DEVPATH_SIZE];
-       char subsystem[SUBSYSTEM_SIZE];
        char bus_id[SYSFS_NAME_LEN];
        char bus[SYSFS_NAME_LEN];
        char program_result[NAME_SIZE];
@@ -81,7 +76,7 @@ extern char **main_argv;
 extern char **main_envp;
 extern char sysfs_path[SYSFS_PATH_MAX];
 extern char udev_root[PATH_MAX];
-extern char udev_db_filename[PATH_MAX+NAME_MAX];
+extern char udev_db_path[PATH_MAX+NAME_MAX];
 extern char udev_permissions_filename[PATH_MAX+NAME_MAX];
 extern char udev_config_filename[PATH_MAX+NAME_MAX];
 extern char udev_rules_filename[PATH_MAX+NAME_MAX];
index 689c2dc..60506b4 100644 (file)
@@ -68,37 +68,6 @@ error:
        return -1;
 }
 
-static int create_path(char *file)
-{
-       char p[NAME_SIZE];
-       char *pos;
-       int retval;
-       struct stat stats;
-       
-       strfieldcpy(p, file);
-       pos = strchr(p+1, '/');
-       while (1) {
-               pos = strchr(pos+1, '/');
-               if (pos == NULL)
-                       break;
-               *pos = 0x00;
-               if (stat(p, &stats)) {
-                       selinux_setfscreatecon(p, S_IFDIR);
-                       retval = mkdir(p, 0755);
-                       if (retval != 0) {
-                               dbg("mkdir(%s) failed with error '%s'",
-                                   p, strerror(errno));
-                               return retval;
-                       }
-                       dbg("created '%s'", p);
-               } else {
-                       selinux_setfilecon(p, S_IFDIR);
-               }
-               *pos = '/';
-       }
-       return 0;
-}
-
 static int make_node(char *file, int major, int minor, unsigned int mode, uid_t uid, gid_t gid)
 {
        struct stat stats;
@@ -152,8 +121,6 @@ exit:
 static int create_node(struct udevice *udev)
 {
        char filename[NAME_SIZE];
-       char linkname[NAME_SIZE];
-       char linktarget[NAME_SIZE];
        char partitionname[NAME_SIZE];
        uid_t uid = 0;
        gid_t gid = 0;
@@ -162,8 +129,8 @@ static int create_node(struct udevice *udev)
        char *pos;
        int len;
 
-       strfieldcpy(filename, udev_root);
-       strfieldcat(filename, udev->name);
+       snprintf(filename, NAME_SIZE-1, "%s/%s", udev_root, udev->name);
+       filename[NAME_SIZE-1] = '\0';
 
        switch (udev->type) {
        case 'b':
@@ -239,9 +206,13 @@ static int create_node(struct udevice *udev)
 
        /* create symlink(s) if requested */
        foreach_strpart(udev->symlink, " ", pos, len) {
+               char linkname[NAME_SIZE];
+               char linktarget[NAME_SIZE];
+
                strfieldcpymax(linkname, pos, len+1);
-               strfieldcpy(filename, udev_root);
-               strfieldcat(filename, linkname);
+               snprintf(filename, NAME_SIZE-1, "%s/%s", udev_root, linkname);
+               filename[NAME_SIZE-1] = '\0';
+
                dbg("symlink '%s' to node '%s' requested", filename, udev->name);
                if (!udev->test_run)
                        if (strrchr(linkname, '/'))
@@ -337,7 +308,8 @@ int udev_add_device(struct udevice *udev, struct sysfs_class_device *class_dev)
                            "remove might not work for custom names");
 
                /* use full path to the environment */
-               snprintf(udev->devname, NAME_SIZE-1, "%s%s", udev_root, udev->name);
+               snprintf(udev->devname, NAME_SIZE-1, "%s/%s", udev_root, udev->name);
+               udev->devname[NAME_SIZE-1] = '\0';
 
        } else if (udev->type == 'n') {
                /* look if we want to change the name of the netif */
index ae755f3..1984739 100644 (file)
@@ -42,7 +42,7 @@
 /* global variables */
 char sysfs_path[SYSFS_PATH_MAX];
 char udev_root[PATH_MAX];
-char udev_db_filename[PATH_MAX+NAME_MAX];
+char udev_db_path[PATH_MAX+NAME_MAX];
 char udev_permissions_filename[PATH_MAX+NAME_MAX];
 char udev_rules_filename[PATH_MAX+NAME_MAX];
 char udev_config_filename[PATH_MAX+NAME_MAX];
@@ -72,7 +72,7 @@ static void init_variables(void)
         * If any config values are specified, they will
         * override these values. */
        strfieldcpy(udev_root, UDEV_ROOT);
-       strfieldcpy(udev_db_filename, UDEV_DB);
+       strfieldcpy(udev_db_path, UDEV_DB);
        strfieldcpy(udev_config_filename, UDEV_CONFIG_FILE);
        strfieldcpy(udev_rules_filename, UDEV_RULES_FILE);
        strfieldcpy(udev_permissions_filename, UDEV_PERMISSION_FILE);
@@ -181,24 +181,25 @@ static int parse_config_file(void)
 
                if (strcasecmp(variable, "udev_root") == 0) {
                        strfieldcpy(udev_root, value);
-                       leading_slash(udev_root);
+                       no_trailing_slash(udev_root);
                        continue;
                }
 
                if (strcasecmp(variable, "udev_db") == 0) {
-                       strfieldcpy(udev_db_filename, value);
+                       strfieldcpy(udev_db_path, value);
+                       no_trailing_slash(udev_db_path);
                        continue;
                }
 
                if (strcasecmp(variable, "udev_rules") == 0) {
                        strfieldcpy(udev_rules_filename, value);
-                       no_leading_slash(udev_rules_filename);
+                       no_trailing_slash(udev_rules_filename);
                        continue;
                }
 
                if (strcasecmp(variable, "udev_permissions") == 0) {
                        strfieldcpy(udev_permissions_filename, value);
-                       no_leading_slash(udev_permissions_filename);
+                       no_trailing_slash(udev_permissions_filename);
                        continue;
                }
 
@@ -244,7 +245,7 @@ static void get_dirs(void)
                temp = getenv("SYSFS_PATH");
                if (temp != NULL) {
                        strfieldcpy(sysfs_path, temp);
-                       no_leading_slash(sysfs_path);
+                       no_trailing_slash(sysfs_path);
                }
 
                temp = getenv("UDEV_CONFIG_FILE");
@@ -255,7 +256,7 @@ static void get_dirs(void)
        dbg("sysfs_path='%s'", sysfs_path);
        dbg_parse("udev_root = %s", udev_root);
        dbg_parse("udev_config_filename = %s", udev_config_filename);
-       dbg_parse("udev_db_filename = %s", udev_db_filename);
+       dbg_parse("udev_db_path = %s", udev_db_path);
        dbg_parse("udev_rules_filename = %s", udev_rules_filename);
        dbg_parse("udev_permissions_filename = %s", udev_permissions_filename);
        dbg_parse("udev_log = %d", udev_log);
@@ -264,7 +265,7 @@ static void get_dirs(void)
 
        dbg("udev_root = %s", udev_root);
        dbg("udev_config_filename = %s", udev_config_filename);
-       dbg("udev_db_filename = %s", udev_db_filename);
+       dbg("udev_db_path = %s", udev_db_path);
        dbg("udev_rules_filename = %s", udev_rules_filename);
        dbg("udev_permissions_filename = %s", udev_permissions_filename);
        dbg("udev_log_str = %d", udev_log);
index bd3eeba..7fb45f0 100644 (file)
@@ -120,6 +120,33 @@ void udev_set_values(struct udevice *udev, const char* devpath, const char *subs
        udev->type = get_device_type(devpath, subsystem);
 }
 
+int create_path(const char *path)
+{
+       char p[NAME_SIZE];
+       char *pos;
+       struct stat stats;
+
+       strcpy (p, path);
+       pos = strrchr(p, '/');
+       if (pos == p || pos == NULL)
+               return 0;
+
+       while (pos[-1] == '/')
+               pos--;
+
+       pos[0] = '\0';
+
+       dbg("stat '%s'\n", p);
+       if (stat (p, &stats) == 0 && (stats.st_mode & S_IFMT) == S_IFDIR)
+               return 0;
+
+       if (create_path (p) != 0)
+               return -1;
+
+       dbg("mkdir '%s'\n", p);
+       return mkdir(p, 0755);
+}
+
 int file_map(const char *filename, char **buf, size_t *bufsize)
 {
        struct stat stats;
@@ -161,18 +188,7 @@ size_t buf_get_line(char *buf, size_t buflen, size_t cur)
        return count - cur;
 }
 
-void leading_slash(char *path)
-{
-       int len;
-
-       len = strlen(path);
-       if (len > 0 && path[len-1] != '/') {
-               path[len] = '/';
-               path[len+1] = '\0';
-       }
-}
-
-void no_leading_slash(char *path)
+void no_trailing_slash(char *path)
 {
        int len;
 
@@ -249,9 +265,8 @@ int call_foreach_file(int fnct(char *f) , char *dirname, char *suffix)
 
        /* call function for every file in the list */
        list_for_each_entry_safe(loop_file, tmp_file, &file_list, list) {
-               strfieldcpy(file, dirname);
-               strfieldcat(file, "/");
-               strfieldcat(file, loop_file->name);
+               snprintf(file, NAME_SIZE-1, "%s/%s", dirname, loop_file->name);
+               file[NAME_SIZE-1] = '\0';
 
                fnct(file);
 
index 8a14ef0..94649b6 100644 (file)
@@ -83,11 +83,11 @@ extern char *get_seqnum(void);
 extern char *get_subsystem(char *subsystem);
 extern char get_device_type(const char *path, const char *subsystem);
 extern void udev_set_values(struct udevice *udev, const char* devpath, const char *subsystem);
+extern int create_path(const char *path);
 extern int file_map(const char *filename, char **buf, size_t *bufsize);
 extern void file_unmap(char *buf, size_t bufsize);
 extern size_t buf_get_line(char *buf, size_t buflen, size_t cur);
-extern void leading_slash(char *path);
-extern void no_leading_slash(char *path);
+extern void no_trailing_slash(char *path);
 extern int  call_foreach_file(int fnct(char *f) , char *filename, char *extension);
 extern int set_cloexec_flag (int desc, int value);
 
index cd9d27f..d855fce 100644 (file)
@@ -102,10 +102,9 @@ static int secure_unlink(const char *filename)
        return retval;
 }
 
-static int delete_node(struct udevice *dev)
+static int delete_node(struct udevice *udev)
 {
        char filename[NAME_SIZE];
-       char linkname[NAME_SIZE];
        char partitionname[NAME_SIZE];
        int retval;
        int i;
@@ -113,8 +112,8 @@ static int delete_node(struct udevice *dev)
        int len;
        int num;
 
-       strfieldcpy(filename, udev_root);
-       strfieldcat(filename, dev->name);
+       snprintf(filename, NAME_SIZE-1, "%s/%s", udev_root, udev->name);
+       filename[NAME_SIZE-1] = '\0';
 
        info("removing device node '%s'", filename);
        retval = secure_unlink(filename);
@@ -122,7 +121,7 @@ static int delete_node(struct udevice *dev)
                return retval;
 
        /* remove all_partitions nodes */
-       num = dev->partitions;
+       num = udev->partitions;
        if (num > 0) {
                info("removing all_partitions '%s[1-%i]'", filename, num);
                if (num > PARTITIONS_COUNT) {
@@ -137,13 +136,15 @@ static int delete_node(struct udevice *dev)
        }
 
        /* remove subdirectories */
-       if (strchr(dev->name, '/'))
+       if (strchr(udev->name, '/'))
                delete_path(filename);
 
-       foreach_strpart(dev->symlink, " ", pos, len) {
+       foreach_strpart(udev->symlink, " ", pos, len) {
+               char linkname[NAME_SIZE];
+
                strfieldcpymax(linkname, pos, len+1);
-               strfieldcpy(filename, udev_root);
-               strfieldcat(filename, linkname);
+               snprintf(filename, NAME_SIZE-1, "%s/%s", udev_root, linkname);
+               filename[NAME_SIZE-1] = '\0';
 
                dbg("unlinking symlink '%s'", filename);
                retval = unlink(filename);
@@ -154,7 +155,7 @@ static int delete_node(struct udevice *dev)
                                filename, strerror(errno));
                        return retval;
                }
-               if (strchr(dev->symlink, '/')) {
+               if (strchr(udev->symlink, '/')) {
                        delete_path(filename);
                }
        }
@@ -168,18 +169,14 @@ static int delete_node(struct udevice *dev)
  */
 int udev_remove_device(struct udevice *udev)
 {
-       struct udevice db_dev;
        const char *temp;
        int retval;
 
        if (udev->type != 'b' && udev->type != 'c')
                return 0;
 
-       retval = udevdb_get_dev(udev->devpath, &db_dev);
-       if (retval == 0) {
-               /* copy over the stored values to our device */
-               memcpy(udev, &db_dev, UDEVICE_DB_LEN);
-       } else {
+       retval = udevdb_get_dev(udev);
+       if (retval) {
                /* fall back to kernel name */
                temp = strrchr(udev->devpath, '/');
                if (temp == NULL)
@@ -189,10 +186,10 @@ int udev_remove_device(struct udevice *udev)
        }
 
        dbg("remove name='%s'", udev->name);
-       udevdb_delete_dev(udev->devpath);
+       udevdb_delete_dev(udev);
 
        /* use full path to the environment */
-       snprintf(udev->devname, NAME_SIZE-1, "%s%s", udev_root, udev->name);
+       snprintf(udev->devname, NAME_SIZE-1, "%s/%s", udev_root, udev->name);
 
        return delete_node(udev);
 }
index 6a3357d..fc579a9 100644 (file)
--- a/udevdb.c
+++ b/udevdb.c
@@ -1,10 +1,10 @@
 /*
- * udevdb.c - udev database library
+ * udevdb.c
  *
  * Userspace devfs
  *
  * Copyright (C) 2003 Greg Kroah-Hartman <greg@kroah.com>
- * Copyright (C) 2003 IBM Corp.
+ * Copyright (C) 2004 Kay Sievers <kay.sievers@vrfy.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
  *
  */
 
+
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <stddef.h>
 #include <fcntl.h>
 #include <string.h>
-#include <sys/stat.h>
 #include <errno.h>
-#include <signal.h>
+#include <dirent.h>
 
 #include "libsysfs/sysfs/libsysfs.h"
 #include "udev.h"
 #include "udev_lib.h"
-#include "udev_version.h"
 #include "logging.h"
-#include "namedev.h"
 #include "udevdb.h"
-#include "tdb/tdb.h"
 
-static TDB_CONTEXT *udevdb;
-sig_atomic_t gotalarm;
+#define PATH_TO_NAME_CHAR              '@'
+
+static int get_db_filename(struct udevice *udev, char *filename, int len)
+{
+       char devpath[SYSFS_PATH_MAX];
+       char *pos;
+
+       /* replace '/' to transform path into a filename */
+       strfieldcpy(devpath, udev->devpath);
+       pos = strchr(&devpath[1], '/');
+       while (pos) {
+               pos[0] = PATH_TO_NAME_CHAR;
+               pos = strchr(&pos[1], '/');
+       }
+       snprintf(filename, len-1, "%s%s", udev_db_path, devpath);
+       filename[len-1] = '\0';
+
+       return 0;
+}
 
 int udevdb_add_dev(struct udevice *udev)
 {
-       TDB_DATA key, data;
-       char keystr[SYSFS_PATH_MAX];
+       char filename[SYSFS_PATH_MAX];
+       FILE *f;
 
        if (udev->test_run)
                return 0;
 
-       if (udevdb == NULL)
+       get_db_filename(udev, filename, SYSFS_PATH_MAX);
+
+       create_path(filename);
+
+       f = fopen(filename, "w");
+       if (f == NULL) {
+               dbg("unable to create db file '%s'", filename);
                return -1;
+       }
+       dbg("storing data for device '%s' in '%s'", udev->devpath, filename);
 
-       memset(keystr, 0x00, SYSFS_PATH_MAX);
-       strfieldcpy(keystr, udev->devpath);
-       key.dptr = keystr;
-       key.dsize = strlen(keystr) + 1;
+       fprintf(f, "P:%s\n", udev->devpath);
+       fprintf(f, "N:%s\n", udev->name);
+       fprintf(f, "S:%s\n", udev->symlink);
+       fprintf(f, "A:%d\n", udev->partitions);
 
-       data.dptr = (void *) udev;
-       data.dsize = UDEVICE_DB_LEN;
-       dbg("store key '%s' for device '%s'", keystr, udev->name);
+       fclose(f);
 
-       return tdb_store(udevdb, key, data, TDB_REPLACE); 
+       return 0;
 }
 
-int udevdb_get_dev(const char *path, struct udevice *udev)
+static int parse_db_file(struct udevice *udev, const char *filename)
 {
-       TDB_DATA key, data;
-
-       if (udevdb == NULL)
+       char line[NAME_SIZE];
+       char *bufline;
+       char *buf;
+       size_t bufsize;
+       size_t cur;
+       size_t count;
+
+       if (file_map(filename, &buf, &bufsize) != 0) {
+               dbg("unable to read db file '%s'", filename);
                return -1;
+       }
 
-       if (path == NULL)
-               return -ENODEV;
-
-       key.dptr = (void *)path;
-       key.dsize = strlen(path) + 1;
-
-       data = tdb_fetch(udevdb, key);
-       if (data.dptr == NULL || data.dsize == 0)
-               return -ENODEV;
+       cur = 0;
+       while (cur < bufsize) {
+               count = buf_get_line(buf, bufsize, cur);
+               bufline = &buf[cur];
+               cur += count+1;
+
+               switch(bufline[0]) {
+               case 'P':
+                       if (count > DEVPATH_SIZE)
+                               count = DEVPATH_SIZE-1;
+                       strncpy(udev->devpath, &bufline[2], count-2);
+                       break;
+               case 'N':
+                       if (count > NAME_SIZE)
+                               count = NAME_SIZE-1;
+                       strncpy(udev->name, &bufline[2], count-2);
+                       break;
+               case 'S':
+                       if (count > NAME_SIZE)
+                               count = NAME_SIZE-1;
+                       strncpy(udev->symlink, &bufline[2], count-2);
+                       break;
+               case 'A':
+                       strfieldcpy(line, &bufline[2]);
+                       udev->partitions = atoi(line);
+                       break;
+               }
+       }
 
-       memset(udev, 0x00, sizeof(struct udevice));
-       memcpy(udev, data.dptr, UDEVICE_DB_LEN);
+       if (udev->name[0] == '\0')
+               return -1;
 
        return 0;
 }
 
-int udevdb_delete_dev(const char *path)
+int udevdb_get_dev(struct udevice *udev)
 {
-       TDB_DATA key;
-       char keystr[SYSFS_PATH_MAX];
-
-       if (udevdb == NULL)
-               return -1;
-
-       if (path == NULL)
-               return -EINVAL;
+       char filename[SYSFS_PATH_MAX];
 
-       memset(keystr, 0, sizeof(keystr));
-       strfieldcpy(keystr, path);
+       get_db_filename(udev, filename, SYSFS_PATH_MAX);
 
-       key.dptr = keystr;
-       key.dsize = strlen(keystr) + 1;
-
-       return tdb_delete(udevdb, key);
+       return parse_db_file(udev, filename);
 }
 
-/**
- * udevdb_exit: closes database
- */
-void udevdb_exit(void)
+int udevdb_delete_dev(struct udevice *udev)
 {
-       if (udevdb != NULL) {
-               tdb_close(udevdb);
-               udevdb = NULL;
-       }
-}
+       char filename[SYSFS_PATH_MAX];
+
+       get_db_filename(udev, filename, SYSFS_PATH_MAX);
+       unlink(filename);
 
-/**
- * udevdb_init: initializes database
- * @init_flag: UDEVDB_INTERNAL - database stays in memory
- *            UDEVDB_DEFAULT - database is written to a file
- */
-int udevdb_init(int init_flag)
-{
-       if (init_flag != UDEVDB_DEFAULT && init_flag != UDEVDB_INTERNAL)
-               return -EINVAL;
-
-       tdb_set_lock_alarm(&gotalarm);
-
-       udevdb = tdb_open(udev_db_filename, 0, init_flag, O_RDWR | O_CREAT, 0644);
-       if (udevdb == NULL) {
-               if (init_flag == UDEVDB_INTERNAL)
-                       dbg("unable to initialize in-memory database");
-               else
-                       dbg("unable to initialize database at '%s'", udev_db_filename);
-               return -EACCES;
-       }
        return 0;
 }
 
-/**
- * udevdb_open_ro: open database for reading
- */
-int udevdb_open_ro(void)
+int udevdb_get_dev_byname(struct udevice *udev, const char *name)
 {
-       udevdb = tdb_open(udev_db_filename, 0, 0, O_RDONLY, 0);
-       if (udevdb == NULL) {
-               dbg("unable to open database at '%s'", udev_db_filename);
-               return -EACCES;
+       struct dirent *ent;
+       DIR *dir;
+       char filename[NAME_SIZE];
+       struct udevice db_udev;
+
+       dir = opendir(udev_db_path);
+       if (dir == NULL) {
+               dbg("unable to udev db '%s'", udev_db_path);
+               return -1;
        }
-       return 0;
-}
 
-static int (*user_record_callback) (const char *path, struct udevice *dev);
+       while (1) {
+               ent = readdir(dir);
+               if (ent == NULL || ent->d_name[0] == '\0')
+                       break;
 
-static int traverse_callback(TDB_CONTEXT *tdb, TDB_DATA key, TDB_DATA dbuf, void *state)
-{
-       return user_record_callback((char*) key.dptr, (struct udevice*) dbuf.dptr);
-}
+               if (ent->d_name[0] == '.')
+                       continue;
 
-/**
- * udevdb_call_foreach: dumps whole database by passing record data to user function
- * @user_record_handler: user function called for every record in the database
- */
-int udevdb_call_foreach(int (*user_record_handler) (const char *path, struct udevice *dev))
-{
-       int retval = 0;
+               snprintf(filename, NAME_SIZE-1, "%s/%s", udev_db_path, ent->d_name);
+               filename[NAME_SIZE-1] = '\0';
 
-       if (udevdb == NULL)
-               return -1;
+               memset(&db_udev, 0x00, sizeof(struct udevice));
+               if (parse_db_file(&db_udev, filename) == 0) {
+                       char *pos;
+                       int len;
 
-       if (user_record_handler == NULL) {
-               dbg("invalid user record handling function");
-               return -EINVAL;
-       }
-       user_record_callback = user_record_handler;
-       retval = tdb_traverse(udevdb, traverse_callback, NULL);
-       if (retval < 0)
-               return -ENODEV;
-       else
-               return 0;
-}
+                       if (strncmp(name, db_udev.name, NAME_SIZE) == 0) {
+                               goto found;
+                       }
 
-static struct udevice *find_dev;
-static char *find_path;
-static const char *find_name;
-static int find_found;
+                       foreach_strpart(db_udev.symlink, " ", pos, len) {
+                               if (strncmp(name, pos, len) != 0)
+                                       continue;
 
-static int find_device_by_name(const char *path, struct udevice *udev)
-{
-       char *pos;
-       int len;
-
-       if (strncmp(udev->name, find_name, sizeof(udev->name)) == 0) {
-               memcpy(find_dev, udev, sizeof(struct udevice));
-               strfieldcpymax(find_path, path, NAME_SIZE);
-               find_found = 1;
-               /* stop search */
-               return 1;
+                               if (len == strlen(name))
+                                       goto found;
+                       }
+
+               }
        }
-       /* look for matching symlink*/
-       foreach_strpart(udev->symlink, " ", pos, len) {
-               if (strncmp(pos, find_name, len) != 0)
-                       continue;
 
-               if (len != strlen(find_name))
-                       continue;
+       closedir(dir);
 
-               memcpy(find_dev, udev, sizeof(struct udevice));
-               strfieldcpymax(find_path, path, NAME_SIZE);
-               find_found = 1;
-               return 1;
-       }
-       return 0;
-}
+       return -1;
 
-/**
- * udevdb_get_dev_byname: search device with given name by traversing the whole database
- */
-int udevdb_get_dev_byname(const char *name, char *path, struct udevice *dev)
-{
-       find_found = 0;
-       find_path = path;
-       find_dev = dev;
-       find_name = name;
-       udevdb_call_foreach(find_device_by_name);
-       if (find_found == 1)
-               return 0;
-       else
-               return -1;
+found:
+       closedir(dir);
+
+       strfieldcpy(udev->devpath, db_udev.devpath);
+       strfieldcpy(udev->name, db_udev.name);
+       strfieldcpy(udev->symlink, db_udev.symlink);
+       udev->partitions = db_udev.partitions;
+
+       return 0;
 }
index 6986a0a..4f6b5de 100644 (file)
--- a/udevdb.h
+++ b/udevdb.h
@@ -1,22 +1,34 @@
 /*
- * udevdb header file
+ * udevdb.h
+ *
+ * Userspace devfs
+ *
+ * Copyright (C) 2003 Greg Kroah-Hartman <greg@kroah.com>
+ * Copyright (C) 2004 Kay Sievers <kay.sievers@vrfy.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 version 2 of the License.
+ * 
+ *     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.,
+ *     675 Mass Ave, Cambridge, MA 02139, USA.
+ *
  */
+
 #ifndef _UDEVDB_H_
 #define _UDEVDB_H_
 
-/* Udevdb initialization flags */
-#define UDEVDB_DEFAULT 0       /* defaults database to use file */
-#define UDEVDB_INTERNAL        1       /* don't store db on disk, use in memory */
-
-/* function prototypes */
-extern void udevdb_exit(void);
-extern int udevdb_init(int init_flag);
-extern int udevdb_open_ro(void);
-extern int udevdb_call_foreach(int (*user_record_handler) (const char *path, struct udevice *dev));
 
 extern int udevdb_add_dev(struct udevice *dev);
-extern int udevdb_get_dev(const char *path, struct udevice *dev);
-extern int udevdb_delete_dev(const char *path);
-extern int udevdb_get_dev_byname(const char *name, char *path, struct udevice *dev);
+extern int udevdb_get_dev(struct udevice *dev);
+extern int udevdb_delete_dev(struct udevice *dev);
+
+extern int udevdb_get_dev_byname(struct udevice *udev, const char *name);
 
 #endif /* _UDEVDB_H_ */
index 0588084..a04e6df 100644 (file)
@@ -29,7 +29,7 @@ interface.
 .RB Needs " \-p " or " \-n " specified.
 .br
 Valid types are:
-.BR name ", " symlink ", " mode " ," owner " , " group " , " path " or " all.
+.BR name ", " symlink ", " path " or " all.
 .TP
 .BI \-p " sysfs_path"
 Specify the sysfs path of the device to query.
@@ -46,9 +46,6 @@ attributes along the device chain. Useful for finding
 unique attributes to compose a rule.
 .RB Needs " \-p " specified.
 .TP
-.B \-d
-Dump the whole database.
-.TP
 .B \-h
 Print help text.
 .SH "FILES"
index af2346c..a90bbe1 100644 (file)
@@ -103,19 +103,11 @@ exit:
        return retval;
 }
 
-/* callback for database dump */
-static int print_record(const char *path, struct udevice *dev)
+static int print_record(struct udevice *udev)
 {
-       printf("P: %s\n", path);
-       printf("N: %s\n", dev->name);
-       printf("T: %c\n", dev->type);
-       printf("M: %#o\n", dev->mode);
-       printf("S: %s\n", dev->symlink);
-       printf("O: %s\n", dev->owner);
-       printf("G: %s\n", dev->group);
-       printf("F: %s\n", dev->config_file);
-       printf("L: %i\n", dev->config_line);
-       printf("U: %li\n", dev->config_uptime);
+       printf("P: %s\n", udev->devpath);
+       printf("N: %s\n", udev->name);
+       printf("S: %s\n", udev->symlink);
        printf("\n");
        return 0;
 }
@@ -125,9 +117,6 @@ enum query_type {
        NAME,
        PATH,
        SYMLINK,
-       MODE,
-       OWNER,
-       GROUP,
        ALL
 };
 
@@ -213,7 +202,7 @@ static int process_options(void)
        static const char short_options[] = "adn:p:q:rVh";
        int option;
        int retval = 1;
-       struct udevice dev;
+       struct udevice udev;
        int root = 0;
        int attributes = 0;
        enum query_type query = NONE;
@@ -254,21 +243,6 @@ static int process_options(void)
                                break;
                        }
 
-                       if (strcmp(optarg, "mode") == 0) {
-                               query = MODE;
-                               break;
-                       }
-
-                       if (strcmp(optarg, "owner") == 0) {
-                               query = OWNER;
-                               break;
-                       }
-
-                       if (strcmp(optarg, "group") == 0) {
-                               query = GROUP;
-                               break;
-                       }
-
                        if (strcmp(optarg, "path") == 0) {
                                query = PATH;
                                break;
@@ -290,16 +264,6 @@ static int process_options(void)
                        attributes = 1;
                        break;
 
-               case 'd':
-                       retval = udevdb_open_ro();
-                       if (retval != 0) {
-                               printf("unable to open udev database\n");
-                               exit(2);
-                       }
-                       udevdb_call_foreach(print_record);
-                       udevdb_exit();
-                       exit(0);
-
                case 'V':
                        printf("udevinfo, version %s\n", UDEV_VERSION);
                        exit(0);
@@ -314,12 +278,6 @@ static int process_options(void)
 
        /* process options */
        if (query != NONE) {
-               retval = udevdb_open_ro();
-               if (retval != 0) {
-                       printf("unable to open udev database\n");
-                       return -EACCES;
-               }
-
                if (path[0] != '\0') {
                        /* remove sysfs_path if given */
                        if (strncmp(path, sysfs_path, strlen(sysfs_path)) == 0) {
@@ -334,7 +292,9 @@ static int process_options(void)
                                        pos = path;
                                }
                        }
-                       retval = udevdb_get_dev(pos, &dev);
+                       memset(&udev, 0x00, sizeof(struct udevice));
+                       strfieldcpy(udev.devpath, pos);
+                       retval = udevdb_get_dev(&udev);
                        if (retval != 0) {
                                printf("device not found in database\n");
                                goto exit;
@@ -344,15 +304,21 @@ static int process_options(void)
 
                if (name[0] != '\0') {
                        /* remove udev_root if given */
-                       if (strncmp(name, udev_root, strlen(udev_root)) == 0) {
-                               pos = name + strlen(udev_root);
+                       int len = strlen(udev_root);
+
+                       if (strncmp(name, udev_root, len) == 0) {
+                               pos = &name[len+1];
                        } else
                                pos = name;
-                       retval = udevdb_get_dev_byname(pos, path, &dev);
+
+                       memset(&udev, 0x00, sizeof(struct udevice));
+                       strfieldcpy(udev.name, pos);
+                       retval = udevdb_get_dev_byname(&udev, pos);
                        if (retval != 0) {
                                printf("device not found in database\n");
                                goto exit;
                        }
+
                        goto print;
                }
 
@@ -362,25 +328,16 @@ static int process_options(void)
 print:
                switch(query) {
                case NAME:
-                       if (root)
-                               strfieldcpy(result, udev_root);
-                       strfieldcat(result, dev.name);
+                       if (root) {
+                               snprintf(result, NAME_SIZE-1, "%s/%s", udev_root, udev.name);
+                               result[NAME_SIZE-1] = '\0';
+                       } else {
+                               strfieldcpy(result, udev.name);
+                       }
                        break;
 
                case SYMLINK:
-                       strfieldcpy(result, dev.symlink);
-                       break;
-
-               case MODE:
-                       sprintf(result, "%#o", dev.mode);
-                       break;
-
-               case GROUP:
-                       strfieldcpy(result, dev.group);
-                       break;
-
-               case OWNER:
-                       strfieldcpy(result, dev.owner);
+                       strfieldcpy(result, udev.symlink);
                        break;
 
                case PATH:
@@ -388,7 +345,7 @@ print:
                        break;
 
                case ALL:
-                       print_record(path, &dev);
+                       print_record(&udev);
                        goto exit;
 
                default:
@@ -397,7 +354,6 @@ print:
                printf("%s\n", result);
 
 exit:
-               udevdb_exit();
                return retval;
        }
 
@@ -427,9 +383,6 @@ help:
               "  -q TYPE  query database for the specified value:\n"
               "             'name'    name of device node\n"
               "             'symlink' pointing to node\n"
-              "             'mode'    permissions of node\n"
-              "             'owner'   of node\n"
-              "             'group'   of node\n"
               "             'path'    sysfs device path\n"
               "             'all'     all values\n"
               "\n"
@@ -438,7 +391,6 @@ help:
               "\n"
               "  -r       print udev root\n"
               "  -a       print all SYSFS_attributes along the device chain\n"
-              "  -d       dump whole database\n"
               "  -V       print udev version\n"
               "  -h       print this help text\n"
               "\n");
index c0c72b9..19922f3 100644 (file)
@@ -95,7 +95,7 @@ static void run_udev(const char *subsystem)
        switch (pid) {
        case 0:
                /* child */
-               execl(UDEV_BIN, UDEV_BIN, subsystem, NULL);
+               execl(UDEV_BIN, "udev", subsystem, NULL);
                dbg("exec of child failed");
                _exit(1);
                break;