Attachment #8415 for bug #23367

Lines 7-12 Build-Depends: debhelper (>= 9), Link Here

(-)a/management/univention-directory-listener/debian/control (-1 / +3 lines)
7	ucslint-univention,	7	ucslint-univention,
8	libssl-dev,	8	libssl-dev,
9	libldap2-dev,	9	libldap2-dev,
		10	liblmdb-dev,
10	libdb3-dev,	11	libdb3-dev,
11	python-all-dev,	12	python-all-dev,
12	libunivention-debug-dev (>= 0.8),	13	libunivention-debug-dev (>= 0.8),
Lines 26-32 Depends: ${misc:Depends}, ${shlibs:Depends}, Link Here
26	univention-runit,	27	univention-runit,
27	python2.7-univention,	28	python2.7-univention,
28	python2.7-univention-debug,	29	python2.7-univention-debug,
29	python-univention-lib (>= 1.0.25-1)	30	python-univention-lib (>= 1.0.25-1),
		31	lmdb-utils
30	Conflicts: univention-ldap-listener (<< 2.2.2)	32	Conflicts: univention-ldap-listener (<< 2.2.2)
31	Description: UCS - Directory Listener	33	Description: UCS - Directory Listener
32	UCS Directory Listener is a client for the UCS	34	UCS Directory Listener is a client for the UCS

Lines 50-55 override_dh_install: Link Here

(-)a/management/univention-directory-listener/debian/rules (+1 lines)
50	mv debian/univention-directory-listener/usr/sbin/listener debian/univention-directory-listener/usr/sbin/univention-directory-listener	50	mv debian/univention-directory-listener/usr/sbin/listener debian/univention-directory-listener/usr/sbin/univention-directory-listener
51	mv debian/univention-directory-listener/usr/sbin/dump debian/univention-directory-listener/usr/sbin/univention-directory-listener-dump	51	mv debian/univention-directory-listener/usr/sbin/dump debian/univention-directory-listener/usr/sbin/univention-directory-listener-dump
52	mv debian/univention-directory-listener/usr/sbin/verify debian/univention-directory-listener/usr/sbin/univention-directory-listener-verify	52	mv debian/univention-directory-listener/usr/sbin/verify debian/univention-directory-listener/usr/sbin/univention-directory-listener-verify
		53	mv debian/univention-directory-listener/usr/sbin/convert debian/univention-directory-listener/usr/sbin/univention-directory-listener-convert
53	mv debian/univention-directory-listener/usr/sbin/listener-ctrl debian/univention-directory-listener/usr/sbin/univention-directory-listener-ctrl	54	mv debian/univention-directory-listener/usr/sbin/listener-ctrl debian/univention-directory-listener/usr/sbin/univention-directory-listener-ctrl
54		55
55	override_dh_installinit:	56	override_dh_installinit:

Lines 1-6 Link Here

(-)a/management/univention-directory-listener/debian/univention-directory-listener.install (+1 lines)
1	src/listener usr/sbin/	1	src/listener usr/sbin/
2	src/dump usr/sbin/	2	src/dump usr/sbin/
3	src/verify usr/sbin/	3	src/verify usr/sbin/
		4	src/convert usr/sbin/
4	src/listener-ctrl usr/sbin/	5	src/listener-ctrl usr/sbin/
5	python/get_notifier_id.py usr/share/univention-directory-listener/	6	python/get_notifier_id.py usr/share/univention-directory-listener/
6	python/ldap_server.py usr/lib/univention-directory-listener/system/	7	python/ldap_server.py usr/lib/univention-directory-listener/system/





call_joinscript 03univention-directory-listener.inst

convert_to_lmdb() {
	if [ ! -f /var/lib/univention-directory-listener/cache/data.mdb ]; then
		if [ ! -d /var/lib/univention-directory-listener/cache ]; then
			mkdir /var/lib/univention-directory-listener/cache
		fi
		if [ -f /var/lib/univention-directory-listener/cache.db ]; then
			running=1
			/etc/init.d/univention-directory-listener status >/dev/null \
				&& running=1 || running=0

			if [ "$running" -eq 1 ]; then
				/etc/init.d/univention-directory-listener stop
			fi

			univention-directory-listener-convert \
				/var/lib/univention-directory-listener/cache.db

			chown -R listener.nogroup \
				/var/lib/univention-directory-listener/cache

			if [ "$running" -eq 1 ]; then
				/etc/init.d/univention-directory-listener start
			fi
		fi
	fi
}

if [ "$1" = "configure" -a -n "$2" ]; then
	if dpkg --compare-versions "$2" lt 6.0.7 && dpkg --compare-versions "$2" gt 6.0.0; then

		mv /var/lib/univention-directory-listener/__* /var/univention-backup/listener-cache-ucs_3.0-ms1/
		mv /var/lib/univention-directory-listener/log.* /var/univention-backup/listener-cache-ucs_3.0-ms1/
	fi

	if dpkg --compare-versions "$2" lt 11.0.0-7; then
		convert_to_lmdb
	fi

	/etc/init.d/univention-directory-listener crestart
fi





#
CC ?= gcc

DB_LDLIBS := -llmdb
DB_OBJS := cache.o cache_dn.o cache_entry.o cache_lowlevel.o base64.o filter.o
DB_OBJS := cache.o cache_entry.o cache_lowlevel.o base64.o filter.o

LDAP_LDLIBS := -lldap -llber

CFLAGS += -Wall -Werror -D_FILE_OFFSET_BITS=64
LDLIBS := -luniventiondebug -luniventionconfig -licuuc
LISTENER_LDLIBS := -luniventionpolicy $(LDAP_LDLIBS) -lpython2.7 $(DB_LDLIBS)
LISTENER_OBJS := main.o notifier.o transfile.o handlers.o change.o network.o signals.o select_server.o utils.o $(DB_OBJS)

DEMO_OBJS := demo.o network.o utils.o
VERIFY_LDLIBS := $(LDAP_LDLIBS) $(DB_LDLIBS)
VERIFY_OBJS := verify.o dump_signals.o utils.o $(DB_OBJS)
CONVERT_LDLIBS := $(LDAP_LDLIBS) $(DB_LDLIBS) -ldb3
CONVERT_OBJS := convert.o cache_bdb.o dump_signals.o utils.o $(DB_OBJS)

.PHONY: all
all: listener dump verify convert

listener: $(LISTENER_OBJS)
	$(CC) $(LDFLAGS) -o $@ $^ $(LDLIBS) $(LISTENER_LDLIBS)

verify: $(VERIFY_OBJS)
	$(CC) $(LDFLAGS) -o $@ $^ $(LDLIBS) $(VERIFY_LDLIBS)

convert: $(CONVERT_OBJS)
	$(CC) $(LDFLAGS) -o $@ $^ $(LDLIBS) $(CONVERT_LDLIBS)

cache_bdb.o: cache_bdb.c
	$(CC) $(CFLAGS) -I/usr/include/db3 -DWITH_DB3 -c $^

.PHONY: clean
clean:
	$(RM) *.o listener dump demo verify convert *.db3 *.db42

Lines 24-32 References Link Here

(-)a/management/univention-directory-listener/src/README (+9 lines)
24	+-- network.c	24	+-- network.c
25		25
26	+-- verify.o	26	+-- verify.o
		27	+-- cache_bdb.c
		28	+-- cache_lowlevel.c
		29	+-- cache_entry.c
		30
		31	+-- convert.o
27	+-- cache.c	32	+-- cache.c
28	+-- cache_lowlevel.c	33	+-- cache_lowlevel.c
29	+-- cache_entry.c	34	+-- cache_entry.c
		35	+-- cache_bdb.c
		36	+-- cache_lowlevel.c
		37	+-- cache_entry.c
30		38
31	Files	39	Files
32	-----	40	-----
Lines 49-54 notifier.c The name notifier might be misleading. The main function Link Here
49	"notifier_listener" uses the listener network API (network.c) to	57	"notifier_listener" uses the listener network API (network.c) to
50	receive updates from a notifier and calls the "change" functions.	58	receive updates from a notifier and calls the "change" functions.
51	signals.c Signal handlers are initialized and defined here.	59	signals.c Signal handlers are initialized and defined here.
		60	cache_bdb.c legacy bdb version of cache.c, required for convert.
52		61
53	main.c The listener daemon	62	main.c The listener daemon
54	demo.c Demo program for the notifier client API.	63	demo.c Demo program for the notifier client API.




#include <sys/types.h>
#include <sys/file.h>
#include <sys/stat.h>
#include <lmdb.h>
#include <stdbool.h>
#include <assert.h>
#include <stdint.h>

#include <univention/debug.h>
#include <univention/config.h>

#include "common.h"
#include "cache.h"
#include "cache_dn.h"
#include "cache_lowlevel.h"
#include "cache_entry.h"
#include "network.h"

#include "filter.h"
#include "utils.h"

// #define MASTER_KEY "__master__"
static size_t MASTER_KEY=0;
#define MASTER_KEY_SIZE (sizeof(DNID))

char *cache_dir = "/var/lib/univention-directory-listener";
char *ldap_dir = "/var/lib/univention-ldap";

CacheMasterEntry cache_master_entry;

MDB_env	*env;
MDB_dbi	id2dn;
MDB_dbi	id2entry;
int	mdb_readonly = 0;
static FILE *lock_fp=NULL;

static struct filter cache_filter;

	}
}

/*
int mdb_message_func(const char *msg, void *ctx) {
	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_INFO,
			"%s\n", msg);
	return MDB_SUCCESS;
}
*/

void cache_error_message(int rv, char *msg)
{
	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
		"%s: failed: %s (%d)\n",
		msg, mdb_strerror(rv), rv);
}

int cache_lock(void)


	assert(!lock_fp);

	rv = snprintf(lock_file, PATH_MAX, "%s/cache.lock", cache_dir);
	if (rv < 0 || rv >= PATH_MAX)
		abort();


	return fd;
}

int cache_init(int mdb_flags)
{
	int rv;
	char mdb_dir[PATH_MAX];
	MDB_txn *cache_init_txn;
	int mdb_dbi_flags = MDB_INTEGERKEY;

	if ((mdb_flags & MDB_RDONLY) != 0) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_INFO,
				"cache_init: MDB_RDONLY");
		mdb_readonly = MDB_RDONLY;
	} else {
		mdb_dbi_flags |= MDB_CREATE;
	}

	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
			"cache_init: start");

	snprintf(mdb_dir, PATH_MAX, "%s/cache", cache_dir);

	rv = mdb_env_create(&env);
	if (rv != MDB_SUCCESS) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"cache_init: creating environment handle failed");
		cache_error_message(rv, "cache_init: mdb_env_create");
		return rv;
	}

	rv = mdb_env_set_mapsize(env, 1992294400);
	if (rv != MDB_SUCCESS) {
				/*DB_INIT_LOCK | */DB_INIT_LOG | DB_INIT_TXN |
				DB_RECOVER, 0600)) != 0) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"cache_init: setting mdb mapsize failed");
		cache_error_message(rv, "cache_init: mdb_env_set_mapsize");
		return rv;
	}

	rv = mdb_env_set_maxdbs(env, 2);
	if (rv != MDB_SUCCESS) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"cache_init: setting mdb maxdbs failed");
		cache_error_message(rv, "cache_init: mdb_env_set_maxdbs");
		return rv;
	}

	rv = mdb_env_open(env, mdb_dir, 0, 0600);
	if (rv != MDB_SUCCESS) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"cache_init: opening database failed");
		cache_error_message(rv, "cache_init: mdb_env_open");
		// FIXME: free dbp
		return rv;
	}

	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL,
			"cache_init: Transaction begin");

	rv = mdb_txn_begin(env, NULL, mdb_readonly, &cache_init_txn);
	if (rv != MDB_SUCCESS) {
		cache_error_message(rv, "cache_init: mdb_txn_begin");
		mdb_env_close(env);
		return rv;
	}

	rv = dntree_init(&id2dn, cache_init_txn, mdb_flags);
	if (rv != MDB_SUCCESS) {
		cache_error_message(rv, "dntree_init: mdb_open");
		mdb_txn_abort(cache_init_txn);
		mdb_env_close(env);
		return rv;
	}
	dbp->set_errcall(dbp, cache_error_message);
#endif
	setup_cache_filter();
	return 0;
}

	rv = mdb_dbi_open(cache_init_txn, "id2entry", mdb_dbi_flags, &id2entry);
	if (rv != MDB_SUCCESS) {
		cache_error_message(rv, "cache_init: mdb_open");
		mdb_txn_abort(cache_init_txn);
		mdb_dbi_close(env, id2dn);
		mdb_env_close(env);
		return rv;
	}

	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL,
			"cache_init: Transaction commit");

	rv = mdb_txn_commit(cache_init_txn);
	if (rv != MDB_SUCCESS) {
		cache_error_message(rv, "cache_init: mdb_txn_commit");
		mdb_dbi_close(env, id2dn);
		mdb_dbi_close(env, id2entry);
		mdb_env_close(env);
		return rv;
	}

	setup_cache_filter();
	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
			"cache_init: end");
	return 0;
}

int cache_set_schema_id(const NotifierID value)

	int rv, fd, len;
	char file[PATH_MAX], buf[15];

	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_WARN,
			"Set Schema ID to %ld", value);
	len = snprintf(buf, sizeof buf, "%ld", value);
	if (len < 0 || len >= sizeof buf)
		return len;


int cache_get_master_entry(CacheMasterEntry *master_entry)
{
	int		rv;
	MDB_txn		*read_txn;
	MDB_val		key, data;

	memset(&key, 0, sizeof(MDB_val));
	memset(&data, 0, sizeof(MDB_val));

	key.mv_data=&MASTER_KEY;
	key.mv_size=MASTER_KEY_SIZE;

	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL,
			"cache_get_master_entry: Transaction begin");
	data.flags = DB_DBT_REALLOC;

	rv = mdb_txn_begin(env, NULL, MDB_RDONLY, &read_txn);
	if (rv != MDB_SUCCESS) {
		cache_error_message(rv, "cache_get_master_entry: mdb_txn_begin");
		return rv;
	}

	rv = mdb_get(read_txn, id2entry, &key, &data);
	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL,
			"cache_get_master_entry: got data");
	if (rv == MDB_NOTFOUND) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL,
				"cache_get_master_entry: Transaction abort");
		mdb_txn_abort(read_txn);
		return rv;
	} else if (rv != MDB_SUCCESS) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"cache_get_master_entry: reading master entry from database failed");
		cache_error_message(rv, "cache_get_master_entry: mdb_get");
		mdb_txn_abort(read_txn);
		return rv;
	}

	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL,
		"cache_get_master_entry: Transaction abort");
	mdb_txn_abort(read_txn);

	if (data.mv_size != sizeof(CacheMasterEntry)) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"cache_get_master_entry: master entry has unexpected length");
		return 1;
	}

	memcpy(master_entry, data.mv_data, sizeof(CacheMasterEntry));
	free(data.data);

	return MDB_SUCCESS;
}

/* The dbtxnp argument is only used when WITH_DB42 is defined - useless? */
int cache_update_master_entry(CacheMasterEntry *master_entry, MDB_txn *dbtxnp)
{
	int		rv;
	MDB_txn		*write_txn = dbtxnp;
	MDB_val		key, data;

	memset(&key, 0, sizeof(DBT));
	memset(&data, 0, sizeof(DBT));

	memset(&key, 0, sizeof(MDB_val));
	memset(&data, 0, sizeof(MDB_val));

	key.mv_data=&MASTER_KEY;
	key.mv_size=MASTER_KEY_SIZE;

	data.mv_data=(void*)master_entry;
	data.mv_size=sizeof(CacheMasterEntry);
		flags = DB_AUTO_COMMIT;
	else
#endif
		flags = 0;

	if (!dbtxnp) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL,
				"cache_update_master_entry: Transaction begin");
	}
	if (!dbtxnp
	    && (rv = mdb_txn_begin(env, NULL, 0, &write_txn)) != MDB_SUCCESS) {
		cache_error_message(rv, "cache_update_master_entry: mdb_txn_begin");
		return rv;
	}
	rv = mdb_put(write_txn, id2entry, &key, &data, 0);
	if (rv != MDB_SUCCESS) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"cache_update_master_entry: storing master entry in database failed");
		cache_error_message(rv, "cache_update_master_entry: mdb_put");
		mdb_txn_abort(write_txn);
		return rv;
	}
	if (!dbtxnp) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL,
				"cache_update_master_entry: Transaction commit");
	}
	if (!dbtxnp
	    && (rv = mdb_txn_commit(write_txn)) != MDB_SUCCESS) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"cache_update_master_entry: storing master entry in database failed");
		cache_error_message(rv, "cache_update_master_entry: mdb_txn_commit");
		return rv;
	}

	return MDB_SUCCESS;

	return 0;
}

MDB_txn *cache_new_transaction(NotifierID id, char *dn)
{
#ifdef WITH_DB42
	int			rv;
	MDB_txn			*write_txn;
	CacheMasterEntry	 master_entry;
	NotifierID		*old_id;

	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL,
			"cache_new_transaction: Transaction begin");
	rv = mdb_txn_begin(env, NULL, 0, &write_txn);
	if (rv != MDB_SUCCESS) {
		cache_error_message(rv, "cache_new_transaction: mdb_txn_begin");
		return NULL;
	}

	if (id != 0) {
		rv = cache_get_master_entry(&master_entry);
		if (rv != MDB_SUCCESS) {
			mdb_txn_abort(write_txn);
			return NULL;
		}



		if (*old_id >= id) {
			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"New ID (%ld) is not greater than old"
				" ID (%ld): %s", id, *old_id, dn);
			mdb_txn_abort(write_txn);
			return NULL;
		} else
			*old_id = id;

		rv = cache_update_master_entry(&master_entry, write_txn);
		if (rv != MDB_SUCCESS) {
			mdb_txn_abort(write_txn);
			return NULL;
		}
	}

	return write_txn;
#else
	return NULL;
#endif
}


/* XXX: The NotifierID is passed for future use. Once the journal is
   implemented, entries other than the most recent one can be returned.
   At the moment, the id parameters for cache_update_entry, and
   cache_delete_entry do nothing (at least if WITH_DB42 is undefined) */
static inline int cache_update_entry_in_transaction(NotifierID id, char *dn, CacheEntry *entry, MDB_cursor **id2dn_cursor_pp)
{
	int		rv;
	DNID		dnid;
	MDB_txn		*write_txn;
	MDB_val		key, data;
	u_int32_t	tmp_size = 0;

	memset(&data, 0, sizeof(MDB_val));
	rv = unparse_entry(&data.mv_data, &tmp_size, entry);
	data.mv_size = tmp_size;
	if (rv != 0) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"cache_update_entry: unparsing entry failed");
		return rv;
	}

	signals_block();

	rv = dntree_get_id4dn(*id2dn_cursor_pp, dn, &dnid, true);
	if (rv != MDB_SUCCESS) {
		signals_unblock();
		return rv;
	}

	key.mv_data = &dnid;
	key.mv_size = sizeof(DNID);

	write_txn = mdb_cursor_txn(*id2dn_cursor_pp);
	rv = mdb_put(write_txn, id2entry, &key, &data, 0);
	if (rv != MDB_SUCCESS) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"cache_update_entry: storing entry in database failed: %s", dn);
		cache_error_message(rv, "cache_update_entry: mdb_put");
		signals_unblock();
		return rv;
	}
	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL,
			"put %zu bytes for %s", data.mv_size, dn);

	signals_unblock();

	return rv;
}

inline int cache_update_entry(NotifierID id, char *dn, CacheEntry *entry)
{
	int		rv;
	MDB_txn		*write_txn;
	MDB_cursor	*id2dn_write_cursor_p;

	signals_block();
#ifdef WITH_DB42
	write_txn = cache_new_transaction(id, dn);
	if (write_txn == NULL) {
		signals_unblock();
		free(data.data);
		return 1;
	}
#else
	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL,
			"cache_update_entry: Transaction begin");
	rv = mdb_txn_begin(env, NULL, 0, &write_txn);
	if (rv != MDB_SUCCESS) {
		cache_error_message(rv, "cache_update_entry: mdb_txn_begin");
		return rv;
	}
#endif

	rv = mdb_cursor_open(write_txn, id2dn, &id2dn_write_cursor_p);
	if (rv != MDB_SUCCESS) {
		cache_error_message(rv, "cache_update_entry: mdb_cursor_open");
	if ((rv=dbp->put(dbp, dbtxnp, &key, &data, 0)) != 0) {
		signals_unblock();
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"storing entry in database failed: %s", dn);
		dbp->err(dbp, rv, "put");
#ifdef WITH_DB42
		dbtxnp->abort(dbtxnp);
#endif
		free(data.data);
		return rv;
	}
	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "put %d bytes for %s", data.size, dn);

	rv = cache_update_entry_in_transaction(id, dn, entry, &id2dn_write_cursor_p);

	mdb_cursor_close(id2dn_write_cursor_p);

	if (rv != MDB_SUCCESS) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL,
				"cache_update_entry: Transaction abort");
		mdb_txn_abort(write_txn);
		return rv;
	}

	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL,
			"cache_update_entry: Transaction commit");
	rv = mdb_txn_commit(write_txn);
	if (rv != MDB_SUCCESS) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"cache_update_entry: storing updated entry in database failed");
		cache_error_message(rv, "cache_update_entry: mdb_txn_commit");
		return rv;
	}

	free(data.data);
	return rv;
}


	return rv;
}

static inline int cache_delete_entry_in_transaction(NotifierID id, char *dn, MDB_cursor **id2dn_cursor_pp)
{
	int		rv;
	DNID		dnid;
	MDB_txn		*write_txn;
	MDB_val		key;

	signals_block();

	rv = dntree_get_id4dn(*id2dn_cursor_pp, dn, &dnid, false);
	if (rv != MDB_SUCCESS) {
		signals_unblock();
		return rv;
	}

	key.mv_data = &dnid;
	key.mv_size = sizeof(DNID);

	write_txn = mdb_cursor_txn(*id2dn_cursor_pp);
	rv = mdb_del(write_txn, id2entry, &key, 0);
	if (rv != MDB_SUCCESS && rv != MDB_NOTFOUND) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"cache_delete_entry: removing from database failed: %s", dn);
		cache_error_message(rv, "cache_delete_entry: mdb_del");
		signals_unblock();
		return rv;
	}
#else
	dbtxnp = NULL;
#endif

	rv = dntree_del_id(*id2dn_cursor_pp, dnid);
	if (rv != MDB_SUCCESS) {
		signals_unblock();
		return rv;
				"removing from database failed: %s", dn);
		dbp->err(dbp, rv, "del");
	}

	signals_unblock();

	return rv;
}

int cache_delete_entry(NotifierID id, char *dn)
{
	int		rv;
	MDB_txn		*write_txn;
	MDB_cursor	*id2dn_write_cursor_p;

#ifdef WITH_DB42
	write_txn = cache_new_transaction(id, dn);
	if (write_txn == NULL) {
		return 1;
	}
#else
	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL,
			"cache_delete_entry: Transaction begin");
	rv = mdb_txn_begin(env, NULL, 0, &write_txn);
	if (rv != MDB_SUCCESS) {
		cache_error_message(rv, "cache_delete_entry: mdb_txn_begin");
		return rv;
	}
#endif

	rv = mdb_cursor_open(write_txn, id2dn, &id2dn_write_cursor_p);
	if (rv != MDB_SUCCESS) {
		cache_error_message(rv, "cache_delete_entry: mdb_cursor_open");
		return rv;
	}

	rv = cache_delete_entry_in_transaction(id, dn, &id2dn_write_cursor_p);

	mdb_cursor_close(id2dn_write_cursor_p);

	if (rv != MDB_SUCCESS) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL,
				"cache_update_entry: Transaction abort");
		mdb_txn_abort(write_txn);
		return rv;
	}

	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL,
			"cache_delete_entry: Transaction commit");
	rv = mdb_txn_commit(write_txn);
	if (rv != MDB_SUCCESS) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"cache_delete_entry: storing entry removal from database failed");
		cache_error_message(rv, "cache_delete_entry: mdb_txn_commit");
	}

	return rv;
}


	// convert to a lowercase dn
	lower_dn = lower_utf8(dn);
	rv = cache_delete_entry(id, lower_dn);
	if (strcmp(dn, lower_dn) != 0) {
		mixedcase = true;
		// try again with original dn

	}

	free(lower_dn);
	if (mixedcase) {
		return rv?rv2:rv;	// if rv was bad (!=0) return rv2, otherwise return rv
	} else {
		return rv;
	}
}

int cache_update_or_deleteifunused_entry(NotifierID id, char *dn, CacheEntry *entry, MDB_cursor **id2dn_cursor_pp)
{
	if (entry->module_count == 0)
		return cache_delete_entry_in_transaction(id, dn, id2dn_cursor_pp);
	else
		return cache_update_entry_in_transaction(id, dn, entry, id2dn_cursor_pp);
}

int cache_get_entry(char *dn, CacheEntry *entry)
{
	int		rv;
	DNID		dnid;
	MDB_txn		*read_txn;
	MDB_cursor	*id2dn_read_cursor_p;
	MDB_val		key, data;

	memset(&key, 0, sizeof(MDB_val));
	memset(&data, 0, sizeof(MDB_val));
	memset(entry, 0, sizeof(CacheEntry));

	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL,
			"cache_get_entry: Transaction begin");
	data.flags = DB_DBT_REALLOC;

	rv = mdb_txn_begin(env, NULL, MDB_RDONLY, &read_txn);
	if (rv != MDB_SUCCESS) {
		cache_error_message(rv, "cache_get_entry: mdb_txn_begin");
		return rv;
	}

	rv = mdb_cursor_open(read_txn, id2dn, &id2dn_read_cursor_p);
	if (rv != MDB_SUCCESS) {
		cache_error_message(rv, "cache_get_entry: mdb_cursor_open");
		mdb_txn_abort(read_txn);
		return rv;
	}

	rv = dntree_get_id4dn(id2dn_read_cursor_p, dn, &dnid, false);
	mdb_cursor_close(id2dn_read_cursor_p);
	if (rv == MDB_NOTFOUND) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL,
				"cache_get_entry: Transaction abort");
		mdb_txn_abort(read_txn);
		return rv;
	}

	key.mv_data = &dnid;
	key.mv_size = sizeof(DNID);

	// signals_block();	// TODO: Is this really required?
	rv = mdb_get(read_txn, id2entry, &key, &data);
	// signals_unblock();

	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL,
			"cache_get_entry: Transaction abort");
	mdb_txn_abort(read_txn);

	if (rv == MDB_SUCCESS) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_INFO,
				"got %zu bytes for %s", data.mv_size, dn);
	} else if (rv == MDB_NOTFOUND) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_INFO,
				"cache_get_entry: no cache entry found for %s", dn);
		return rv;
	} else {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"reading %s from database failed", dn);
		cache_error_message(rv, "cache_get_entry: mdb_get");
		return rv;
	}

	assert(data.mv_size <= UINT32_MAX);
	rv = parse_entry(data.mv_data, data.mv_size, entry);
	if (rv != 0) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"cache_get_entry: parsing entry failed");
		free(data.data);
		exit(1);
	}

	free(data.data);
	return rv;
}


	}

	rv = cache_get_entry(lower_dn, entry);
	if (rv == MDB_NOTFOUND && mixedcase ) {
		// try again with original dn
		rv = cache_get_entry(dn, entry);
	}

	return rv;
}

int cache_first_entry(MDB_cursor **id2entry_read_cursor_pp, MDB_cursor **id2dn_read_cursor_pp, char **dn, CacheEntry *entry)
{
	MDB_txn *read_txn;
	int rv;

	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL,
			"cache_first_entry: Transaction begin");

	rv = mdb_txn_begin(env, NULL, mdb_readonly, &read_txn);
	if (rv != MDB_SUCCESS) {
		cache_error_message(rv, "cache_first_entry: mdb_txn_begin");
		return rv;
	}

	rv = mdb_cursor_open(read_txn, id2entry, id2entry_read_cursor_pp);
	if (rv != MDB_SUCCESS) {
		cache_error_message(rv, "cache_first_entry: mdb_cursor_open");
		mdb_txn_abort(read_txn);
		return rv;
	}

	rv = mdb_cursor_open(read_txn, id2dn, id2dn_read_cursor_pp);
	if (rv != MDB_SUCCESS) {
		cache_error_message(rv, "cache_first_entry: mdb_cursor_open");
		mdb_txn_abort(read_txn);
		return rv;
	}

	/*
	// mdb_reader_list(env, &mdb_message_func, NULL);
	MDB_envinfo stat;
	MDB_env *env = mdb_txn_env(read_txn);
	mdb_env_info(env, &stat);
	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "LAST COMMITTED TXN: %zu", stat.me_last_txnid);
	*/

	return cache_next_entry(id2entry_read_cursor_pp, id2dn_read_cursor_pp, dn, entry);
}

int cache_print_entries(char *dn)
{
	int		rv;
	DNID		dnid;
	MDB_txn		*read_txn;
	MDB_cursor	*id2dn_read_cursor_p;
	MDB_cursor	*id2entry_read_cursor_p;
	MDB_val		key, data;

	memset(&key, 0, sizeof(MDB_val));
	memset(&data, 0, sizeof(MDB_val));

	rv = mdb_txn_begin(env, NULL, MDB_RDONLY, &read_txn);
	if (rv != MDB_SUCCESS) {
		cache_error_message(rv, "cache_print_entries: mdb_txn_begin");
		return rv;
	}

	rv = mdb_cursor_open(read_txn, id2dn, &id2dn_read_cursor_p);
	if (rv != MDB_SUCCESS) {
		cache_error_message(rv, "cache_print_entries: mdb_cursor_open");
		mdb_txn_abort(read_txn);
		return rv;
	}

	// rv = cache_dntree_get_id(id2dn_read_cursor_p, dn, &dnid, false);
	rv = dntree_get_id4dn(id2dn_read_cursor_p, dn, &dnid, false);
	mdb_cursor_close(id2dn_read_cursor_p);
	if (rv == MDB_NOTFOUND) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL,
				"cache_print_entries: Transaction abort");
		mdb_txn_abort(read_txn);
		return rv;
	}

	key.mv_data = &dnid;
	key.mv_size = sizeof(DNID);

	rv = mdb_cursor_open(read_txn, id2entry, &id2entry_read_cursor_p);
	if (rv != MDB_SUCCESS) {
		cache_error_message(rv, "cache_print_entries: mdb_cursor_open");
		mdb_txn_abort(read_txn);
		return rv;
	}
	rv = mdb_cursor_get(id2entry_read_cursor_p, &key, &data, MDB_FIRST);
	do {
		if (rv != MDB_SUCCESS) {
			cache_error_message(rv, "cache_print_entries: mdb_cursor_get");
			mdb_txn_abort(read_txn);
			return rv;
		}
		printf("%s\n", dn);
		printf("%s\n", (char*)data.mv_data); //TODO: Is that what we want?
	} while ((rv = mdb_cursor_get(id2entry_read_cursor_p, &key, &data, MDB_NEXT)));

	mdb_cursor_close(id2entry_read_cursor_p);
	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL,
			"cache_print_entries: Transaction abort");
	mdb_txn_abort(read_txn);
	return MDB_SUCCESS;
}

int cache_next_entry(MDB_cursor **id2entry_read_cursor_pp, MDB_cursor **id2dn_read_cursor_pp, char **dn, CacheEntry *entry)
{
	MDB_val key, data;
	DNID dnid;
	int rv;

	memset(&key, 0, sizeof(MDB_val));
	memset(&data, 0, sizeof(MDB_val));
	memset(&data, 0, sizeof(DBT));
	data.flags = DB_DBT_REALLOC;

	/* Get the next entry data */
	rv = mdb_cursor_get(*id2entry_read_cursor_pp, &key, &data, MDB_NEXT);
	if (rv == MDB_NOTFOUND) {
		return rv;
	} else if (rv != MDB_SUCCESS) {
		cache_error_message(rv, "cache_next_entry: mdb_cursor_get");
		return rv;
	}

	// skip root node
	dnid = * (DNID *) key.mv_data;
	if (dnid == MASTER_KEY) {
		return cache_next_entry(id2entry_read_cursor_pp, id2dn_read_cursor_pp, dn, entry);
		return cache_next_entry(cur, dn, entry);
	}

	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL,
			"got %zu bytes", data.mv_size);
	*dn = strdup(key.data);

	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "got %d bytes", data.size);

	assert(data.mv_size <= UINT32_MAX);
	rv = parse_entry(data.mv_data, (u_int32_t) data.mv_size, entry);
	if (rv != 0) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"cache_next_entry: parsing entry failed: %s", *dn);
		printf("%zu\n", data.mv_size);
		free(key.data);
		free(data.data);
		return rv;
	}

	/* Get the corresponding dn */
	if (*dn) {
		free(*dn);
		*dn = NULL;
	}
		
	rv = dntree_lookup_dn4id(*id2dn_read_cursor_pp, dnid, dn);

	if (rv != MDB_SUCCESS) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"cache_next_entry: DB corruption, DN entry for id %d not found",
				*(int*)key.mv_data);
		cache_error_message(rv, "cache_next_entry: mdb_get");
		return rv;
	}

	return 0;
}

int cache_free_cursor(MDB_cursor *id2entry_read_cursor_pp, MDB_cursor *id2dn_read_cursor_pp)
{
	int rv = 0;
	MDB_txn *read_txn;

	/*
	// mdb_reader_list(env, &mdb_message_func, NULL);
	MDB_envinfo stat;
	MDB_env *env = mdb_txn_env(read_txn);
	mdb_env_info(env, &stat);
	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "LAST COMMITTED TXN: %zu", stat.me_last_txnid);
	*/

	read_txn = mdb_cursor_txn(id2entry_read_cursor_pp);
	mdb_cursor_close(id2entry_read_cursor_pp);
	mdb_cursor_close(id2dn_read_cursor_pp);

	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL,
			"cache_free_cursor: Transaction commit");
	rv = mdb_txn_commit(read_txn);
	if (rv != MDB_SUCCESS) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"cache_free_cursor: Transation commit failed");
		cache_error_message(rv, "cache_free_cursor: mdb_txn_commit");
	}
	return rv;
}

void cache_close(void)
{
	mdb_close(env, id2dn);
	mdb_close(env, id2entry);
	mdb_env_close(env);

	if (dbp && (rv = dbp->close(dbp, 0)) != 0) {
		dbp->err(dbp, rv, "close");
	}
	dbp = NULL;
#ifdef WITH_DB42
	if ((rv = dbenvp->close(dbenvp, 0)) != 0) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"closing database environment failed");
	}
#endif
	if (lock_fp != NULL) {
		fclose(lock_fp);
		lock_fp = NULL;
	}
	return rv;
}




#ifndef _CACHE_H_
#define _CACHE_H_

#include <lmdb.h>

#include "network.h"
#include "cache_entry.h"

extern CacheMasterEntry cache_master_entry;

int	cache_lock(void);
int	cache_init				(int mdb_flags);
void	cache_sync(void);
int	cache_get_master_entry			(CacheMasterEntry	 *master_entry);
int	cache_update_master_entry		(CacheMasterEntry	 *master_entry,
						 MDB_txn		 *dptxnp);
int	cache_update_entry			(NotifierID		  id,
						 char			 *dn,
						 CacheEntry		 *entry);

						 char			 *dn);
int	cache_update_or_deleteifunused_entry	(NotifierID		  id,
						 char			 *dn,
						 CacheEntry		 *entry,
						 MDB_cursor		**cur);
int	cache_get_entry(
						 char			 *dn,
						 CacheEntry		 *entry);
int	cache_get_entry_lower_upper(
						 char			 *dn,
						 CacheEntry		 *entry);
int	cache_first_entry			(MDB_cursor		**cur,
						 MDB_cursor		**cur_dn,
						 char			**dn,
						 CacheEntry		 *entry);
int	cache_next_entry			(MDB_cursor		**cur,
						 MDB_cursor		**cur_dn,
						 char			**dn,
						 CacheEntry		 *entry);
int	cache_free_cursor			(MDB_cursor		 *cur,
						 MDB_cursor		 *cur_dn);
void	cache_close				(void);

/* deprecated with DB42*/
int	cache_set_int				(char		 *key,




/*
 * Univention Directory Listener
 *  ldap listener caching system
 *
 * Copyright 2004-2017 Univention GmbH
 *
 * http://www.univention.de/
 *
 * All rights reserved.
 *
 * The source code of this program is made available
 * under the terms of the GNU Affero General Public License version 3
 * (GNU AGPL V3) as published by the Free Software Foundation.
 *
 * Binary versions of this program provided by Univention to you as
 * well as other copyrighted, protected or trademarked materials like
 * Logos, graphics, fonts, specific documentations and configurations,
 * cryptographic keys etc. are subject to a license agreement between
 * you and Univention and not subject to the GNU AGPL V3.
 *
 * In the case you use this program under the terms of the GNU AGPL V3,
 * the program is provided 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 Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public
 * License with the Debian GNU/Linux or Univention distribution in file
 * /usr/share/common-licenses/AGPL-3; if not, see
 * <http://www.gnu.org/licenses/>.
 */

/* How it works:

   LDAP entries are cached here. If a modification takes place,
   the new LDAP entry is compared with the cache entry, and both,
   old and new entries, are passed to the handler modules.

   Berkeley DB provides a way to store and receive a chunk of data
   with a given key. However, we're not working with cache entries
   as chunks of data later, but use C structures. So we'll need to
   convert the C structure we can work with to chunks of data we
   can store in BDB, and the other way around.

   We have decided on a pretty low level, but straightforward
   binary format for the chunk of data. For manual error recovery, a
   text-based format like LDIF might have been easier.

   The function unparse_entry converts a C structure entry to a data
   chunk, parse_entry does the opposite.

   To convert the entry, unparse_entry walks through all values of
   all attributes, as well as through the list of modules registered
   with it, and write a block for each (attribute, value) pair or
   (, module) [write_header]. Each block starts with an entry_header
   structure that specified the lengths of the following data.
*/


#define _GNU_SOURCE /* for strndup */

#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <unistd.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/file.h>
#include <sys/stat.h>
#include <db.h>
#include <stdbool.h>
#include <assert.h>

#include <univention/debug.h>
#include <univention/config.h>

#include "common.h"
#include "cache_bdb.h"
#include "cache_lowlevel.h"
#include "cache_entry.h"
#include "network.h"
#include "signals.h"
#include "filter.h"
#include "utils.h"

#define MASTER_KEY "__master__"
#define MASTER_KEY_SIZE (sizeof MASTER_KEY)

char *bdb_cache_dir = "/var/lib/univention-directory-listener";
char *bdb_ldap_dir = "/var/lib/univention-ldap";

BdbCacheMasterEntry bdb_cache_master_entry;

DB *dbp;
#ifdef WITH_DB42
DB_ENV *dbenvp;
#endif
static FILE *lock_fp=NULL;

static struct filter cache_filter;
static struct filter *cache_filters[] = {&cache_filter, NULL};

static void setup_cache_filter(void) {
	FREE(cache_filter.filter);
	FREE(cache_filter.base);
	cache_filter.filter = univention_config_get_string("listener/cache/filter");
	if (cache_filter.filter && cache_filter.filter[0]) {
		cache_filter.base = univention_config_get_string("ldap/base");
		cache_filter.scope = LDAP_SCOPE_SUBTREE;
	}
}

#ifdef WITH_DB42
static void bdb_cache_panic_call(DB_ENV *dbenvp, int errval)
{
	exit(1);
}
#endif

static void bdb_cache_error_message(const char *errpfx, char *msg)
{
	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
			"database error: %s", msg);
}

int bdb_cache_lock(void)
{
	int rv, fd;
	char lock_file[PATH_MAX];

	assert(!lock_fp);

	rv = snprintf(lock_file, PATH_MAX, "%s/cache.db.lock", bdb_cache_dir);
	if (rv < 0 || rv >= PATH_MAX)
		abort();

	if ((lock_fp = fopen(lock_file, "a+e")) == NULL) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"Could not open lock file [%s]", lock_file);
		exit(EXIT_FAILURE);
	}
	fd = fileno(lock_fp);

	if (lockf(fd, F_TLOCK, 0) != 0) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"Could not get lock for database [%s]; "
				"Is another listener processs running?\n",
				lock_file);
		exit(EXIT_FAILURE);
	}

	return fd;
}

int bdb_cache_init(void)
{
	int rv;
	char file[PATH_MAX];

	snprintf(file, PATH_MAX, "%s/cache.db", bdb_cache_dir);

#ifdef WITH_DB42
	if ((rv = db_env_create(&dbenvp, 0)) != 0) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"creating database environment failed");
		return rv;
	}
	dbenvp->set_errcall(dbenvp, bdb_cache_error_message);
	dbenvp->set_paniccall(dbenvp, bdb_cache_panic_call);
	if ((rv = dbenvp->open(dbenvp, bdb_cache_dir, DB_CREATE | DB_INIT_MPOOL |
				/*DB_INIT_LOCK | */DB_INIT_LOG | DB_INIT_TXN |
				DB_RECOVER, 0600)) != 0) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"opening database environment failed");
		dbenvp->err(dbenvp, rv, "%s", "environment");
		return rv;
	}
	if ((rv = db_create(&dbp, dbenvp, 0)) != 0) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"creating database handle failed");
		return rv;
	}
	if ((rv = dbp->open(dbp, NULL, "cache.db", NULL, DB_BTREE,
				DB_CREATE | DB_CHKSUM | DB_AUTO_COMMIT,
				0600)) != 0) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"opening database failed");
		dbp->err(dbp, rv, "open");
		// FIXME: free dbp
		return rv;
	}
#else
	if ((rv = db_create(&dbp, NULL, 0)) != 0) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"creating database handle failed");
		return rv;
	}
	if ((rv = dbp->open(dbp, file, NULL, DB_BTREE, DB_CREATE, 0600)) != 0) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"opening database failed");
		dbp->err(dbp, rv, "open");
		// FIXME: free dbp
		return rv;
	}
	dbp->set_errcall(dbp, bdb_cache_error_message);
#endif
	setup_cache_filter();
	return 0;
}

void bdb_cache_sync(void) {
	if (dbp) {
		dbp->sync(dbp, 0);
	}
}

int bdb_cache_set_schema_id(const NotifierID value)
{
	int rv, fd, len;
	char file[PATH_MAX], buf[15];

	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_WARN, "Set Schema ID to %ld", value);
	len = snprintf(buf, sizeof buf, "%ld", value);
	if (len < 0 || len >= sizeof buf)
		return len;

	rv = snprintf(file, PATH_MAX, "%s/schema/id/id", bdb_ldap_dir);
	if (rv < 0 || rv >= PATH_MAX)
		return rv;
	fd = open(file, O_WRONLY | O_CREAT, 0644);
	if (fd < 0)
		return fd;
	rv = write(fd, buf, len);
	if (rv != len) {
		close(fd);
		return 1;
	}
	rv = ftruncate(fd, len);
	if (rv != 0)
		return rv;
	rv = close(fd);
	if (rv != 0)
		return rv;
	return 0;
}

int bdb_cache_get_schema_id(NotifierID *value, const long def)
{
	FILE *fp;
	char file[PATH_MAX];
	int rv;

	*value = def;

	snprintf(file, PATH_MAX, "%s/schema/id/id", bdb_ldap_dir);
	if ((fp = fopen(file, "r")) == NULL)
		return 1;
	rv = fscanf(fp, "%ld", value);
	return fclose(fp) || (rv != 1);
}

int bdb_cache_set_int(char *key, const NotifierID value)
{
	int rv;
	FILE *fp;
	char file[PATH_MAX], tmpfile[PATH_MAX];

	rv = snprintf(tmpfile, PATH_MAX, "%s/%s.tmp", bdb_cache_dir, key);
	if (rv < 0 || rv >= PATH_MAX)
		return rv;
	if ((fp = fopen(tmpfile, "w")) == NULL)
		abort_io("open", tmpfile);
	fprintf(fp, "%ld", value);
	rv = fclose(fp);
	if (rv != 0)
		abort_io("close", tmpfile);

	rv = snprintf(file, PATH_MAX, "%s/%s", bdb_cache_dir, key);
	if (rv < 0 || rv >= PATH_MAX)
		return rv;
	rv = rename(tmpfile, file);
	return rv;
}

int bdb_cache_get_int(char *key, NotifierID *value, const long def)
{
	FILE *fp;
	char file[PATH_MAX];
	int rv;

	*value = def;

	snprintf(file, PATH_MAX, "%s/%s", bdb_cache_dir, key);
	if ((fp = fopen(file, "r")) == NULL)
		return 1;
	rv = fscanf(fp, "%ld", value);
	return fclose(fp) || (rv != 1);
}

int bdb_cache_get_master_entry(BdbCacheMasterEntry *master_entry)
{
	DBT key, data;
	int rv;

	memset(&key, 0, sizeof(DBT));
	memset(&data, 0, sizeof(DBT));

	key.data=MASTER_KEY;
	key.size=MASTER_KEY_SIZE;
	data.flags = DB_DBT_REALLOC;

	if ((rv=dbp->get(dbp, NULL, &key, &data, 0)) == DB_NOTFOUND)
		return rv;
	else if (rv != 0) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"reading master entry from database failed");
		dbp->err(dbp, rv, "get");
		return rv;
	}

	if (data.size != sizeof(BdbCacheMasterEntry)) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"master entry has unexpected length");
		return 1;
	}

	memcpy(master_entry, data.data, sizeof(BdbCacheMasterEntry));
	free(data.data);

	return 0;
}

int bdb_cache_update_master_entry(BdbCacheMasterEntry *master_entry, DB_TXN *dbtxnp)
{
	DBT key, data;
	int rv;
	int flags;

	memset(&key, 0, sizeof(DBT));
	memset(&data, 0, sizeof(DBT));

	key.data=MASTER_KEY;
	key.size=MASTER_KEY_SIZE;

	data.data=(void*)master_entry;
	data.size=sizeof(BdbCacheMasterEntry);

#ifdef WITH_DB42
	if (dbtxnp == NULL)
		flags = DB_AUTO_COMMIT;
	else
#endif
		flags = 0;

	if ((rv=dbp->put(dbp, dbtxnp, &key, &data, flags)) != 0) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"storing master entry in database failed");
		dbp->err(dbp, rv, "put");
		return rv;
	}

	bdb_cache_sync();

	return 0;
}

DB_TXN* bdb_cache_new_transaction(NotifierID id, char *dn)
{
#ifdef WITH_DB42
	DB_TXN			*dbtxnp;
	BdbCacheMasterEntry	 master_entry;
	NotifierID		*old_id;

	dbenvp->txn_begin(dbenvp, NULL, &dbtxnp, 0);

	if (id != 0) {
		if (bdb_cache_get_master_entry(&master_entry) != 0) {
			dbtxnp->abort(dbtxnp);
			return NULL;
		}

		if (strcmp(dn, "cn=Subschema") == 0)
			old_id = &master_entry.schema_id;
		else
			old_id = &master_entry.id;

		if (*old_id >= id) {
			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
					"New ID (%ld) is not greater than old"
					" ID (%ld): %s", id, *old_id, dn);
			dbtxnp->abort(dbtxnp);
			return NULL;
		} else
			*old_id = id;

		if (bdb_cache_update_master_entry(&master_entry, dbtxnp) != 0) {
			dbtxnp->abort(dbtxnp);
			return NULL;
		}
	}

	return dbtxnp;
#else
	return NULL;
#endif
}


/* XXX: The NotifierID is passed for future use. Once the journal is
   implemented, entries other than the most recent one can be returned.
   At the moment, the id parameters for bdb_cache_update_entry, and
   bdb_cache_delete_entry do nothing (at least if WITH_DB42 is undefined) */
inline int bdb_cache_update_entry(NotifierID id, char *dn, CacheEntry *entry)
{
	DBT key, data;
	DB_TXN *dbtxnp;
	int rv = 0;

	memset(&key, 0, sizeof(DBT));
	memset(&data, 0, sizeof(DBT));

	if ((rv=unparse_entry(&data.data, &data.size, entry)) != 0) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"unparsing entry failed");
		return rv;
	}


	signals_block();
#ifdef WITH_DB42
	dbtxnp = bdb_cache_new_transaction(id, dn);
	if (dbtxnp == NULL) {
		signals_unblock();
		free(data.data);
		return 1;
	}
#else
	dbtxnp = NULL;
#endif

	key.data=dn;
	key.size=strlen(dn)+1;

	if ((rv=dbp->put(dbp, dbtxnp, &key, &data, 0)) != 0) {
		signals_unblock();
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"storing entry in database failed: %s", dn);
		dbp->err(dbp, rv, "put");
#ifdef WITH_DB42
		dbtxnp->abort(dbtxnp);
#endif
		free(data.data);
		return rv;
	}
	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "put %d bytes for %s", data.size, dn);


#ifdef WITH_DB42
	dbtxnp->commit(dbtxnp, 0);
#endif
	bdb_cache_sync();
	signals_unblock();

	free(data.data);
	return rv;
}

int bdb_cache_update_entry_lower(NotifierID id, char *dn, CacheEntry *entry)
{
	char *lower_dn;
	int rv = 0;

	if (cache_filter.filter && cache_entry_ldap_filter_match(cache_filters, dn, entry)) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "Not caching %s, filtered out.", dn);
		return rv;
	}

	lower_dn = lower_utf8(dn);
	rv = bdb_cache_update_entry(id, lower_dn, entry);

	free(lower_dn);
	return rv;
}

int bdb_cache_delete_entry(NotifierID id, char *dn)
{
	DB_TXN	*dbtxnp;
	DBT	 key;
	int	 rv;

	memset(&key, 0, sizeof(DBT));

	key.data=dn;
	key.size=strlen(dn)+1;

	signals_block();
#ifdef WITH_DB42
	dbtxnp = bdb_cache_new_transaction(id, dn);
	if (dbtxnp == NULL) {
		signals_unblock();
		return 1;
	}
#else
	dbtxnp = NULL;
#endif

	if ((rv=dbp->del(dbp, dbtxnp, &key, 0)) != 0 && rv != DB_NOTFOUND) {
		signals_unblock();
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"removing from database failed: %s", dn);
		dbp->err(dbp, rv, "del");
	}

#ifdef WITH_DB42
	dbtxnp->commit(dbtxnp, 0);
#endif
	bdb_cache_sync();
	signals_unblock();

	return rv;
}

int bdb_cache_delete_entry_lower_upper(NotifierID id, char *dn)
{
	char *lower_dn;
	bool mixedcase = false;
	int	 rv, rv2;

	// convert to a lowercase dn
	lower_dn = lower_utf8(dn);
	rv=bdb_cache_delete_entry(id, lower_dn);
	if (strcmp(dn, lower_dn) != 0) {
		mixedcase = true;
		// try again with original dn
		rv2=bdb_cache_delete_entry(id, dn);
	}

	free(lower_dn);
	if ( mixedcase ) {
		return rv?rv2:rv;	// if rv was bad (!=0) return rv2, otherwise return rv
	} else {
		return rv;
	}
}

int bdb_cache_update_or_deleteifunused_entry(NotifierID id, char *dn, CacheEntry *entry)
{
	if (entry->module_count == 0)
		return bdb_cache_delete_entry(id, dn);
	else
		return bdb_cache_update_entry(id, dn, entry);
}

int bdb_cache_get_entry(char *dn, CacheEntry *entry)
{
	DBT key, data;
	int rv = 0;

	memset(&key, 0, sizeof(DBT));
	memset(&data, 0, sizeof(DBT));
	memset(entry, 0, sizeof(CacheEntry));

	key.data=dn;
	key.size=strlen(dn)+1;
	data.flags = DB_DBT_REALLOC;

	signals_block();
	rv=dbp->get(dbp, NULL, &key, &data, 0);
	signals_unblock();

	if (rv != 0 && rv != DB_NOTFOUND) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"reading %s from database failed", dn);
		dbp->err(dbp, rv, "get");
		return rv;
	} else if (rv == DB_NOTFOUND) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "no cache entry found for %s",
				dn);
		return rv;
	}

	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "got %d bytes for %s",
			data.size, dn);

	if ((rv=parse_entry(data.data, data.size, entry)) != 0) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"parsing entry failed");
		free(data.data);
		exit(1);
	}

	free(data.data);
	return rv;
}

int bdb_cache_get_entry_lower_upper(char *dn, CacheEntry *entry)
{
	char *lower_dn;
	bool mixedcase = false;
	int	 rv;

	// convert to a lowercase dn
	lower_dn = lower_utf8(dn);
	if (strcmp(dn, lower_dn) != 0) {
		mixedcase = true;
	}

	rv = bdb_cache_get_entry(lower_dn, entry);
	if (rv == DB_NOTFOUND && mixedcase ) {
		// try again with original dn
		rv = bdb_cache_get_entry(dn, entry);
	}

	free(lower_dn);
	return rv;
}

int bdb_cache_first_entry(DBC **cur, char **dn, CacheEntry *entry)
{
	int rv;

	if ((rv=dbp->cursor(dbp, NULL, cur, 0)) != 0) {
		dbp->err(dbp, rv, "cursor");
		return rv;
	}

	return bdb_cache_next_entry(cur, dn, entry);
}

int bdb_cache_print_entries(char *dn)
{
	DBT key, data;
	DBC *cur;
	memset(&key, 0, sizeof(DBT));
	memset(&data, 0, sizeof(DBT));
	key.data = strdup(dn);
	key.size = strlen(dn)+1;
	key.flags = DB_DBT_REALLOC;
	data.flags = DB_DBT_REALLOC;

	dbp->cursor(dbp, NULL, &cur, 0);
	cur->c_get(cur, &key, &data, DB_FIRST);
	do {
		printf("%s\n", (char*)key.data);
	} while (cur->c_get(cur, &key, &data, DB_NEXT) == 0);

	cur->c_close(cur);
	free(key.data);
	free(data.data);
	return 0;
}

int bdb_cache_next_entry(DBC **cur, char **dn, CacheEntry *entry)
{
	DBT key, data;
	int rv;

	memset(&key, 0, sizeof(DBT));
	key.flags = DB_DBT_REALLOC;
	memset(&data, 0, sizeof(DBT));
	data.flags = DB_DBT_REALLOC;

	if ((rv=(*cur)->c_get(*cur, &key, &data, DB_NEXT)) == DB_NOTFOUND) {
		return rv;
	} else if (rv != 0) {
		dbp->err(dbp, rv, "c_get");
		return rv;
	}

	/* skip master entry */
	if (strcmp(key.data, MASTER_KEY) == 0) {
		free(key.data);
		free(data.data);
		return bdb_cache_next_entry(cur, dn, entry);
	}

	if (*dn)
		free(*dn);
	*dn = strdup(key.data);

	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "got %d bytes", data.size);

	if ((rv=parse_entry(data.data, data.size, entry)) != 0) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"parsing entry failed: %s", *dn);
		printf("%d\n", data.size);
		free(key.data);
		free(data.data);
		return rv;
	}

	free(key.data);
	free(data.data);

	return 0;
}

int bdb_cache_free_cursor(DBC *cur)
{
	return cur->c_close(cur);
}

int bdb_cache_close(void)
{
	int rv = 0;

	if (dbp && (rv = dbp->close(dbp, 0)) != 0) {
		dbp->err(dbp, rv, "close");
	}
	dbp = NULL;
#ifdef WITH_DB42
	if ((rv = dbenvp->close(dbenvp, 0)) != 0) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"closing database environment failed");
	}
#endif
	if (lock_fp != NULL) {
		fclose(lock_fp);
		lock_fp = NULL;
	}
	return rv;
}




/*
 * Univention Directory Listener
 *  header information for cache.c
 *
 * Copyright 2004-2017 Univention GmbH
 *
 * http://www.univention.de/
 *
 * All rights reserved.
 *
 * The source code of this program is made available
 * under the terms of the GNU Affero General Public License version 3
 * (GNU AGPL V3) as published by the Free Software Foundation.
 *
 * Binary versions of this program provided by Univention to you as
 * well as other copyrighted, protected or trademarked materials like
 * Logos, graphics, fonts, specific documentations and configurations,
 * cryptographic keys etc. are subject to a license agreement between
 * you and Univention and not subject to the GNU AGPL V3.
 *
 * In the case you use this program under the terms of the GNU AGPL V3,
 * the program is provided 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 Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public
 * License with the Debian GNU/Linux or Univention distribution in file
 * /usr/share/common-licenses/AGPL-3; if not, see
 * <http://www.gnu.org/licenses/>.
 */

#ifndef _CACHE_BDB_H_
#define _CACHE_BDB_H_

#include <db.h>

#include "network.h"
#include "cache_entry.h"

extern char *bdb_cache_dir;
extern char *bdb_ldap_dir;

typedef struct _BdbCacheMasterEntry {
	NotifierID id;
	NotifierID schema_id;
} BdbCacheMasterEntry;
extern BdbCacheMasterEntry bdb_cache_master_entry;

int	bdb_cache_lock(void);
int	bdb_cache_init				(void);
void	bdb_cache_sync(void);
int	bdb_cache_get_master_entry			(BdbCacheMasterEntry	 *master_entry);
int	bdb_cache_update_master_entry		(BdbCacheMasterEntry	 *master_entry,
						 DB_TXN			 *dptxnp);
int	bdb_cache_update_entry			(NotifierID		  id,
						 char			 *dn,
						 CacheEntry		 *entry);
inline int	bdb_cache_update_entry_lower			(NotifierID		  id,
						 char			 *dn,
						 CacheEntry		 *entry);
int	bdb_cache_delete_entry			(NotifierID		  id,
						 char			 *dn);
int	bdb_cache_delete_entry_lower_upper			(NotifierID		  id,
						 char			 *dn);
int	bdb_cache_update_or_deleteifunused_entry	(NotifierID		  id,
						 char			 *dn,
						 CacheEntry		 *entry);
int	bdb_cache_get_entry(
						 char			 *dn,
						 CacheEntry		 *entry);
int	bdb_cache_get_entry_lower_upper(
						 char			 *dn,
						 CacheEntry		 *entry);
int	bdb_cache_first_entry			(DBC			**cur,
						 char			**dn,
						 CacheEntry		 *entry);
int	bdb_cache_next_entry			(DBC			**cur,
						 char			**dn,
						 CacheEntry		 *entry);
int	bdb_cache_free_cursor			(DBC			 *cur);
int	bdb_cache_close				(void);

/* deprecated with DB42*/
int	bdb_cache_set_int				(char		 *key,
						 const NotifierID		  value);
int	bdb_cache_get_int				(char		 *key,
						 NotifierID			 *value,
						 const long		  def);

int bdb_cache_get_schema_id(NotifierID *value, const long def);
int bdb_cache_set_schema_id(const NotifierID value);

#endif /* _CACHE_BDB_H_ */




/*
 *  example implementation for mdb dntree adjecency list
 *
 * Copyright 2016 Univention GmbH
 * Copyright 2016 Arvid Requate
 *
 * http://www.univention.de/
 *
 * All rights reserved.
 *
 * The source code of this program is made available
 * under the terms of the GNU Affero General Public License version 3
 * (GNU AGPL V3) as published by the Free Software Foundation.
 *
 * Binary versions of this program provided by Univention to you as
 * well as other copyrighted, protected or trademarked materials like
 * Logos, graphics, fonts, specific documentations and configurations,
 * cryptographic keys etc. are subject to a license agreement between
 * you and Univention and not subject to the GNU AGPL V3.
 *
 * In the case you use this program under the terms of the GNU AGPL V3,
 * the program is provided 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 Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public
 * License with the Debian GNU/Linux or Univention distribution in file
 * /usr/share/common-licenses/AGPL-3; if not, see
 * <http://www.gnu.org/licenses/>.
 */

/*
 * Derived From: This code is derived from dn2id.c written by Howard Chu.
 * The code of dn2id.c has been published under OpenLDAP Public License.
 *
 * A copy of this license is available in the file LICENSE in the
 * top-level directory of the distribution or, alternatively, at
 * <http://www.OpenLDAP.org/license.html>.
 */

#include <stdio.h>
#include <unistd.h>
#include <malloc.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <assert.h>
#include "cache_dn.h"
#include <univention/debug.h>

int mdb_dupsort(const MDB_val *a, const MDB_val *b)
{
	int		diff;
	subDN		*sdn_a, *sdn_b;

	sdn_a = (subDN *)a->mv_data;
	sdn_b = (subDN *)b->mv_data;

	diff = sdn_a->type - sdn_b->type;
	if (diff) {
		return diff;
	}
	if (sdn_a->type == SUBDN_TYPE_LINK) {
		return strcmp(sdn_a->data, sdn_b->data);
	} else {
		return 0;
	}
}

unsigned int num_rdns(LDAPDN dn) {
	unsigned int	iRDN;

	for (iRDN=0; dn[iRDN]; iRDN++);

	return iRDN;
}

/* climb the dntree */
static int dntree_lookup_id4ldapdn(MDB_cursor *cur, LDAPDN dn, DNID *dnid_out, int *found_out)
{
	int		rv, iRDN, found;
	MDB_val		key, data;
	DNID		parent, id = 0;
	char		*rdn;
	subDN		*subdn;

	key.mv_size = sizeof(DNID);

	found = 0;
	iRDN = num_rdns(dn);
	for (iRDN--; iRDN>=0; iRDN--) {
		rv = ldap_rdn2str(dn[iRDN], &rdn, LDAP_DN_FORMAT_LDAPV3);
		if (rv != LDAP_SUCCESS) {
			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"%s: ldap_rdn2str failed: %s (%d)",
				__func__, ldap_err2string(rv), rv);
			return rv;
		}

		key.mv_data = &parent;
		parent = id;

		data.mv_size = sizeof(subDN) + strlen(rdn);
		subdn = malloc(data.mv_size);
		if (subdn == NULL) {
			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"%s: Malloc failed", __func__);
			ldap_memfree(rdn);
			abort();
		}
		subdn->type = SUBDN_TYPE_LINK;
		strcpy(subdn->data, rdn);
		ldap_memfree(rdn);
		data.mv_data = subdn;

		rv = mdb_cursor_get(cur, &key, &data, MDB_GET_BOTH);
		free(subdn);

		if (rv == MDB_NOTFOUND) {
			break;
		}
		if (rv != MDB_SUCCESS) {
			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"%s: mdb_cursor_get failed: %s (%d)",
			           __func__, ldap_err2string(rv), rv);
			return rv;
		};

		subdn = (subDN *) data.mv_data;
		id = subdn->id;
		found++;
	}

	if (rv == MDB_SUCCESS) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_INFO,
			"%s: found id=%lu",
		        __func__, id);
	} else if (rv != MDB_NOTFOUND) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
			"%s: failed: %s (%d)",
		        __func__, mdb_strerror(rv), rv);
	}

	*dnid_out = id; 
	if (found_out) {
		*found_out = found;
	};

	return rv;
}

int dntree_lookup_dn4id(MDB_cursor *cur, DNID dnid, char **dn)
{
	int		rv;
	MDB_val		key, data;
	subDN		*subdn;
	DNID		id = dnid;

	key.mv_size = sizeof(DNID);
	key.mv_data = &id;

	data.mv_size = sizeof(subDN);
	subdn = malloc(data.mv_size);
	if (subdn == NULL) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
			"%s: Malloc failed", __func__);
		abort();
	}
	subdn->type = SUBDN_TYPE_NODE;
	data.mv_data = subdn;

	rv = mdb_cursor_get(cur, &key, &data, MDB_GET_BOTH);
	free(subdn);
	data.mv_data = NULL;
	data.mv_size = 0;

	if (rv != MDB_SUCCESS) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
			"%s: mdb_cursor_get (MDB_GET_BOTH): %s (%d)",
		        __func__, mdb_strerror(rv), rv);
		return rv;
	};

	// Workaround for (ITS#8393) LMDB - MDB_GET_BOTH broken on non-dup value
	rv = mdb_cursor_get(cur, &key, &data, MDB_GET_CURRENT);
	if (rv != MDB_SUCCESS) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
			"%s: mdb_cursor_get: %s (%d)",
		        __func__, mdb_strerror(rv), rv);
		return rv;
	};

	/*
	 * or simply use this instead of MDB_GET_BOTH + MDB_GET_CURRENT:
	MDB_txn		*txn;
	MDB_dbi		dbi;
	txn = mdb_cursor_txn(cur);
	dbi = mdb_cursor_dbi(cur);
	rv = mdb_get(txn, dbi, &key, &data);
	if (rv != MDB_SUCCESS) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
			"%s: mdb_get: %s (%d)",
		        __func__, mdb_strerror(rv), rv);
		return rv;
	};
	*/

	subdn = (subDN *) data.mv_data;

	*dn = malloc(strlen(subdn->data) + 1);
	if (*dn == NULL) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
			"%s: Malloc failed", __func__);
		abort();
	}
	strcpy(*dn, subdn->data);

	return rv;
}

static int next_free_dnid(MDB_cursor *cur, DNID *dnid_out)
{
	int		rv;
	MDB_val		key;

	rv = mdb_cursor_get(cur, &key, NULL, MDB_LAST);
	if (rv == MDB_SUCCESS) {
		*dnid_out = (*(DNID *) key.mv_data) + 1;
		return rv;
	} else if (rv == MDB_NOTFOUND) {
		*dnid_out = 1;
		return MDB_SUCCESS;
	} else {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
			"%s: mdb_cursor_get: %s (%d)",
		        __func__, mdb_strerror(rv), rv);
		return rv;
	}
}

static int dntree_add_id(MDB_cursor *write_cursor_p, DNID child, LDAPDN dn, DNID parent)
{
	int		rv;
	MDB_val		key, data;
	DNID		id;
	char		*rdn_str;
	char		*dn_str;
	size_t		dn_len;
	size_t		rdn_len;
	subDN		*subdn;

	key.mv_size = sizeof(DNID);
	key.mv_data = &id;
	id = parent;

	rv = ldap_dn2str(dn, &dn_str, LDAP_DN_FORMAT_LDAPV3);
	if (rv != LDAP_SUCCESS) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
			"%s: ldap_dn2str failed: %s (%d)",
		        __func__, ldap_err2string(rv), rv);
		return rv;
	}

	rv = ldap_rdn2str(dn[0], &rdn_str, LDAP_DN_FORMAT_LDAPV3);
	if (rv != LDAP_SUCCESS) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
			"%s: ldap_rdn2str failed: %s (%d)",
		        __func__, ldap_err2string(rv), rv);
		ldap_memfree(dn_str);
		return rv;
	}

	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_INFO,
		"%s: child=%lu, parent=%lu: \"%s\"",
	        __func__, child, parent, rdn_str);

	dn_len = strlen(dn_str);
	subdn = malloc(sizeof(subDN) + dn_len);
	rdn_len = strlen(rdn_str);
	assert(dn_len >= rdn_len);
	data.mv_size = sizeof(subDN) + rdn_len;
	if (subdn == NULL) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
			"%s: Malloc failed", __func__);
		ldap_memfree(dn_str);
		ldap_memfree(rdn_str);
		abort();
	}
	subdn->type = SUBDN_TYPE_LINK;
	subdn->id = child;
	strcpy(subdn->data, rdn_str);
	ldap_memfree(rdn_str);
	data.mv_data = subdn;

	// Store subdn link
	rv = mdb_cursor_put(write_cursor_p, &key, &data, MDB_NODUPDATA);

	// Store subdn node
	if (rv == MDB_SUCCESS) {
		id = child;

		data.mv_size = sizeof(subDN) + dn_len;
		subdn->type = SUBDN_TYPE_NODE;
		subdn->id = parent;	// backlink
		strcpy(subdn->data, dn_str);

		rv = mdb_cursor_put(write_cursor_p, &key, &data, MDB_NODUPDATA);
		if (rv != MDB_SUCCESS) {
			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"%s: mdb_cursor_put failed for child %lu: %s (%d)",
			        __func__, id, mdb_strerror(rv), rv);
		}
	} else {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
			"%s: mdb_cursor_put failed for parent %lu: %s (%d)",
		        __func__, id, mdb_strerror(rv), rv);
	}
	ldap_memfree(dn_str);
	free(subdn);

	return rv;
}

static int dntree_has_children(MDB_cursor *local_cursor, DNID dnid)
{
	int		rv;
	size_t		values;
	MDB_val		key, data;

	key.mv_size = sizeof(DNID);
	key.mv_data = &dnid;

	rv = mdb_cursor_get(local_cursor, &key, &data, MDB_SET);
	if (rv != MDB_SUCCESS) {
		return rv;
	}

	rv = mdb_cursor_count(local_cursor, &values);
	if (rv == MDB_SUCCESS && values < 2) {
		rv = MDB_NOTFOUND;
	}
	return rv;
}

int dntree_del_id(MDB_cursor *write_cursor_p, DNID dnid)
{
	int		rv;
	MDB_val		key, data;
	MDB_cursor	*local_read_cursor_p;
	MDB_txn		*txn;
	MDB_dbi		dbi;

	txn = mdb_cursor_txn(write_cursor_p);
	dbi = mdb_cursor_dbi(write_cursor_p);
	rv = mdb_cursor_open(txn, dbi, &local_read_cursor_p);
	if (rv != MDB_SUCCESS) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
			"%s: mdb_cursor_open: %s (%d)",
		        __func__, ldap_err2string(rv), rv);
		return rv;
	}

	rv = dntree_has_children(local_read_cursor_p, dnid);
	if (rv == MDB_SUCCESS) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
			"%s: delete failed:"
		        " subordinate objects must be deleted first",
		        __func__);
		return -1;
	} else if (rv != MDB_NOTFOUND) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
			"%s: dntree_has_children failed: %s (%d)",
		        __func__, mdb_strerror(rv), rv);
		return -1;
	}
	mdb_cursor_close(local_read_cursor_p);

	// dntree_lookup_id4ldapdn positioned cursor on SUBDN_TYPE_LINK node below parent's key
	rv = mdb_cursor_del(write_cursor_p, 0);

	if (rv == MDB_SUCCESS) {
		key.mv_size = sizeof(DNID);
		key.mv_data = &dnid;
		rv = mdb_cursor_get(write_cursor_p, &key, &data, MDB_SET);
		if (rv == MDB_SUCCESS) {
			rv = mdb_cursor_del(write_cursor_p, 0);
		}
	}

	return rv;
}

int dntree_del_ldapdn(MDB_cursor *write_cursor_p, LDAPDN dn)
{
	int		rv;
	DNID		id;

	rv = dntree_lookup_id4ldapdn(write_cursor_p, dn, &id, NULL);
	if (rv != MDB_SUCCESS) {
		return rv;
	}

	return dntree_del_id(write_cursor_p, id);
}


static int dntree_get_id4ldapdn(MDB_cursor *write_cursor_p, LDAPDN dn, DNID *dnid_out)
{
	int		rv, found;
	DNID		id, parent = 0;
	LDAPDN		pdn;

	if (dn == NULL) {
		*dnid_out = 0;
		return MDB_SUCCESS;
	}

	rv = dntree_lookup_id4ldapdn(write_cursor_p, dn, &id, &found);
	if (rv == MDB_NOTFOUND) {
		pdn = &dn[1];
		if (num_rdns(pdn) != found) {
			rv = dntree_get_id4ldapdn(write_cursor_p, pdn, &parent); 
			if (rv != MDB_SUCCESS) {
				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
					"%s: failed: %s (%d)",
				        __func__, mdb_strerror(rv), rv);
				return rv;
			}
		} else {
			parent = id;
		}
		rv = next_free_dnid(write_cursor_p, &id);
		if (rv != MDB_SUCCESS) {
			return rv;
		}
		rv = dntree_add_id(write_cursor_p, id, dn, parent);
	}

	*dnid_out = id;

	return rv;
}

int dntree_get_id4dn(MDB_cursor *id2dn_cursor_p, char *dn, DNID *dnid, bool create)
{
	int		rv;
	LDAPDN		ldapdn;

	rv = ldap_str2dn(dn, &ldapdn, LDAP_DN_FORMAT_LDAP);
	if (rv != LDAP_SUCCESS) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
			"%s: ldap_str2dn failed: %s (%d)",
		        __func__, ldap_err2string(rv), rv);
		return rv;
	}

	if (ldapdn == NULL) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
			"%s: ldap_str2dn NULL: %s (%d): %s",
		        __func__, ldap_err2string(rv), rv, dn);
		return 1;
	}

	if (create == true) {
		rv = dntree_get_id4ldapdn(id2dn_cursor_p, ldapdn, dnid); 
		if (rv != MDB_SUCCESS) {
			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"%s: failed for: %s",
			        __func__, dn);
		}
		
	} else {
		rv = dntree_lookup_id4ldapdn(id2dn_cursor_p, ldapdn, dnid, NULL);
		if (rv == MDB_NOTFOUND) {
			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_INFO,
				"%s: DN %s not in id2dn",
			        __func__, dn);
		}
	}

	ldap_dnfree(ldapdn);
	return rv;
}

int dntree_del_dn(MDB_cursor *write_cursor_p, char *dn)
{
	int		rv;
	LDAPDN		ldapdn;

	rv = ldap_str2dn(dn, &ldapdn, LDAP_DN_FORMAT_LDAP);
	if (rv != LDAP_SUCCESS) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
			"%s: ldap_str2dn failed: %s (%d)",
		        __func__, ldap_err2string(rv), rv);
		return rv;
	}

	if (ldapdn == NULL) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
			"%s: ldap_str2dn NULL: %s (%d): %s",
		        __func__, ldap_err2string(rv), rv, dn);
		return 1;
	}

	rv = dntree_del_ldapdn(write_cursor_p, ldapdn); 

	ldap_dnfree(ldapdn);
	return rv;
}


int dntree_init(MDB_dbi *dbi_p, MDB_txn *cache_init_txn_p, int mdb_flags)
{
	int		rv;
	MDB_val		key, data;
	MDB_cursor	*cur;
	int		mdb_dbi_flags = MDB_INTEGERKEY|MDB_DUPSORT;
	bool		readonly = (mdb_flags & MDB_RDONLY) != 0;

	if (!readonly) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_INFO,
				"dntree_init: MDB_RDONLY");
		mdb_dbi_flags |= MDB_CREATE;
	}

	rv = mdb_dbi_open(cache_init_txn_p, "id2dn", mdb_dbi_flags, dbi_p);
	if (rv != MDB_SUCCESS) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
			"%s: mdb_dbi_open: %s (%d)",
			__func__, mdb_strerror(rv), rv);
		return rv;
	};
	rv = mdb_set_dupsort(cache_init_txn_p, *dbi_p, mdb_dupsort);
	if (rv != MDB_SUCCESS) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
			"%s: mdb_set_dupsort: %s (%d)",
			__func__, mdb_strerror(rv), rv);
		return rv;
	};

	if (readonly) {
		return MDB_SUCCESS;
	}

	rv = mdb_cursor_open(cache_init_txn_p, *dbi_p, &cur);
	if (rv != MDB_SUCCESS) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
			"%s: mdb_cursor_open: %s (%d)",
			__func__, mdb_strerror(rv), rv);
		return rv;
	};

	// create root node
	key.mv_size = sizeof(DNID);
	key.mv_data = &(DNID) {0};
	data.mv_size = sizeof(subDN);
	data.mv_data = &(subDN) {0, SUBDN_TYPE_NODE, {0}};
	// ignore exists
	mdb_cursor_put(cur, &key, &data, MDB_NODUPDATA);
	// not strictly required, mdb_txn_commit does it for write txn
	mdb_cursor_close(cur);

	return MDB_SUCCESS;
}




/*
 *  header information for dntree.c
 *
 * Copyright 2016 Univention GmbH
 * Copyright 2016 Arvid Requate
 *
 * http://www.univention.de/
 *
 * All rights reserved.
 *
 * The source code of this program is made available
 * under the terms of the GNU Affero General Public License version 3
 * (GNU AGPL V3) as published by the Free Software Foundation.
 *
 * Binary versions of this program provided by Univention to you as
 * well as other copyrighted, protected or trademarked materials like
 * Logos, graphics, fonts, specific documentations and configurations,
 * cryptographic keys etc. are subject to a license agreement between
 * you and Univention and not subject to the GNU AGPL V3.
 *
 * In the case you use this program under the terms of the GNU AGPL V3,
 * the program is provided 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 Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public
 * License with the Debian GNU/Linux or Univention distribution in file
 * /usr/share/common-licenses/AGPL-3; if not, see
 * <http://www.gnu.org/licenses/>.
 */

#ifndef _DNTREE_H_
#define _DNTREE_H_

#include <stdbool.h>
#include <lmdb.h>
#include <ldap.h>

typedef struct mdb_ctx {
	MDB_env		*env;
	MDB_dbi		dbi;
	MDB_txn		*txn;
	MDB_cursor	*cur;
} mdb_ctx;

#define	SUBDN_TYPE_NODE 0
#define	SUBDN_TYPE_LINK 1

typedef unsigned char SUBDNTYPE;
typedef unsigned long DNID;
typedef struct subDN {
	DNID id;
	SUBDNTYPE type;
	char data[1];
} subDN;

int dntree_init(MDB_dbi *dbi_ptr, MDB_txn *write_txn_p, int mdb_flags);
int dntree_get_id4dn(MDB_cursor *cursor, char *dn, DNID *dnid, bool create);
int dntree_lookup_dn4id(MDB_cursor *cur, DNID dnid, char **dn);
int dntree_del_id(MDB_cursor *cursor, DNID dnid);
int dntree_del_ldapdn(MDB_cursor *cursor, LDAPDN dn);

#endif /* _DNTREE_H_ */




#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <lmdb.h>

#include <univention/debug.h>
#include <univention/config.h>

	struct filter **f;
	int rv;
	CacheEntry cache_entry, old_cache_entry;
	MDB_cursor *id2entry_read_cursor_p = NULL;
	MDB_cursor *id2dn_read_cursor_p = NULL;
	char *dn = NULL;
	int i;
	bool abort_init = false;

	/* remove old entries for module */
	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_INFO,
			"remove old entries for module %s", handler->name);
	for (rv=cache_first_entry(&id2entry_read_cursor_p, &id2dn_read_cursor_p, &dn, &cache_entry); rv != MDB_NOTFOUND;
			rv=cache_next_entry(&id2entry_read_cursor_p, &id2dn_read_cursor_p, &dn, &cache_entry)) {
		if (rv == -1) continue;
		if (rv < 0) break;

		cache_entry_module_remove(&cache_entry, handler->name);
		cache_update_or_deleteifunused_entry(0, dn, &cache_entry, &id2dn_read_cursor_p);
		cache_free_entry(&dn, &cache_entry);
	}

	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_INFO,
			"call cache_free_cursor for module %s", handler->name);
	cache_free_cursor(id2entry_read_cursor_p, id2dn_read_cursor_p);

	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_INFO,
			"initialize schema for module %s", handler->name);
	/* initialize schema; if it's not in cache yet (it really should be), it'll
	   be initialized on the regular schema check after ldapsearches */
	if ((rv = cache_get_entry_lower_upper("cn=Subschema", &cache_entry)) != 0 &&
			rv != MDB_NOTFOUND) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_WARN,
				"error while reading from database");
		return LDAP_OTHER;

		for (i=0; i<dn_count; i++) {
			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "DN: %s", dns[i].dn);

			if ((rv = cache_get_entry_lower_upper(dns[i].dn, &cache_entry)) == MDB_NOTFOUND) { /* XXX */
				LDAPMessage *res2, *first;
				int attrsonly0 = 0;
				rv = LDAP_RETRY(lp, ldap_search_ext_s(lp->ld, dns[i].dn, LDAP_SCOPE_BASE, "(objectClass=*)", attrs, attrsonly0, serverctrls, clientctrls, &timeout, sizelimit0, &res2));

		}
	}
	INIT_ONLY = old_init_only;
	cache_sync();

	return 0;
}

		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_WARN, "error while converting LDAP entry to cache entry");
		goto result;
	}
	if ((rv = cache_get_entry_lower_upper(dn, &old_cache_entry)) != 0 && rv != MDB_NOTFOUND) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_WARN, "error while reading from database");
		rv = LDAP_OTHER;
	} else {

	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_PROCESS, "updating '%s' command %c", trans->cur.notify.dn, trans->cur.notify.command);

	rv = cache_get_entry_lower_upper(trans->cur.notify.dn, &trans->cur.cache);
	if (rv != 0 && rv != MDB_NOTFOUND) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_WARN, "error reading database for %s", trans->cur.notify.dn);
		return LDAP_OTHER;
	}




/*
 * Univention Directory Listener
 *  tool to convert the cache.
 *
 * Copyright 2016-2017 Univention GmbH
 *
 * http://www.univention.de/
 *
 * All rights reserved.
 *
 * The source code of this program is made available
 * under the terms of the GNU Affero General Public License version 3
 * (GNU AGPL V3) as published by the Free Software Foundation.
 *
 * Binary versions of this program provided by Univention to you as
 * well as other copyrighted, protected or trademarked materials like
 * Logos, graphics, fonts, specific documentations and configurations,
 * cryptographic keys etc. are subject to a license agreement between
 * you and Univention and not subject to the GNU AGPL V3.
 *
 * In the case you use this program under the terms of the GNU AGPL V3,
 * the program is provided 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 Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public
 * License with the Debian GNU/Linux or Univention distribution in file
 * /usr/share/common-licenses/AGPL-3; if not, see
 * <http://www.gnu.org/licenses/>.
 */

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>
#include <dirent.h>
#include <pwd.h>
#include <sys/types.h>

#include <univention/debug.h>

#include "cache_bdb.h"
#include "cache.h"
#include "common.h"


static void usage(void)
{
	fprintf(stderr, "Usage: univention-directory-listener-convert [options]\n");
	fprintf(stderr, "Options:\n");
	fprintf(stderr, "   -d   debugging\n");
	fprintf(stderr, "   -c   Listener cache path\n");
}


int main(int argc, char* argv[])
{
	int debugging = 0;
	int rv;
	DBC *cur;
	char *dn = NULL;
	CacheEntry entry;

	univention_debug_init("stderr", 1, 1);

	/* parse arguments */
	for (;;) {
		int c;

		c = getopt(argc, argv, "d:c:");
		if (c < 0)
			break;
		switch (c) {
		case 'd':
			debugging=atoi(optarg);
			break;
		case 'c':
			cache_dir=strdup(optarg);
			bdb_cache_dir=strdup(optarg);
			break;
		default:
			usage();
			exit(1);
		}
	}

	if (debugging > 1) {
		univention_debug_set_level(UV_DEBUG_LISTENER, UV_DEBUG_ALL);
		univention_debug_set_level(UV_DEBUG_LDAP, UV_DEBUG_ALL);
		univention_debug_set_level(UV_DEBUG_KERBEROS, UV_DEBUG_ALL);
	} else if ( debugging > 0 ) {
		univention_debug_set_level(UV_DEBUG_LISTENER, UV_DEBUG_INFO);
		univention_debug_set_level(UV_DEBUG_LDAP, UV_DEBUG_INFO);
		univention_debug_set_level(UV_DEBUG_KERBEROS, UV_DEBUG_INFO);
	} else {
		univention_debug_set_level(UV_DEBUG_LISTENER, UV_DEBUG_ERROR);
		univention_debug_set_level(UV_DEBUG_LDAP, UV_DEBUG_ERROR);
		univention_debug_set_level(UV_DEBUG_KERBEROS, UV_DEBUG_ERROR);
	}

	rv = bdb_cache_lock();
	rv = cache_lock();

	if (bdb_cache_init() != 0)
		exit(1);

	if (cache_init(0) != 0)
		exit(1);

	bdb_cache_get_master_entry(&bdb_cache_master_entry);
	rv = cache_update_master_entry(&cache_master_entry, NULL);

	for (rv=bdb_cache_first_entry(&cur, &dn, &entry); rv != DB_NOTFOUND;
			rv=bdb_cache_next_entry(&cur, &dn, &entry)) {
		if (rv != 0) {
			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
			                 "error while reading database");
		} else if ((rv=cache_update_entry_lower(0, dn, &entry)) != MDB_SUCCESS) {
				univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				                 "error while writing to database");
		}
		cache_free_entry(&dn, &entry);
		if (rv < -1) break;
	}

	bdb_cache_free_cursor(cur);

	bdb_cache_close();
	cache_close();

	return 0;
}




	char *output_file = NULL;
	FILE *fp;
	int rv;
	MDB_cursor *id2entry_read_cursor_p = NULL;
	MDB_cursor *id2dn_read_cursor_p = NULL;
	char *dn = NULL;
	CacheEntry entry;


			"Couldn't open dump file");
		exit(1);
	}
	if (cache_init(MDB_RDONLY) != 0)
		exit(1);

	if (id_only) {

		printf("%ld %ld\n", cache_master_entry.id, cache_master_entry.schema_id);
	} else {

	for (rv=cache_first_entry(&id2entry_read_cursor_p, &id2dn_read_cursor_p, &dn, &entry); rv != MDB_NOTFOUND;
			rv=cache_next_entry(&id2entry_read_cursor_p, &id2dn_read_cursor_p, &dn, &entry)) {
		if ((rv == 0 && !broken_only) || (rv == -1 && broken_only)) {
			cache_dump_entry(dn, &entry, fp);
			fprintf(fp, "\n");

		cache_free_entry(&dn, &entry);
		if (rv < -1) break;
	}
	cache_free_cursor(id2entry_read_cursor_p, id2dn_read_cursor_p);

	}


Lines 536-542 int main(int argc, char* argv[]) Link Here

(-)a/management/univention-directory-listener/src/main.c (-2 / +3 lines)
536		536
537	/* XXX: we shouldn't block all signals for so long */	537	/* XXX: we shouldn't block all signals for so long */
538	signals_block();	538	signals_block();
539	cache_init();	539	if (cache_init(0) != 0)
		540	exit(1);
540	handlers_init();	541	handlers_init();
541		542
542	/* pass data to handlers */	543	/* pass data to handlers */
Lines 560-566 int main(int argc, char* argv[]) Link Here
560		561
561	/* if no ID is set, assume the database has just been initialized */	562	/* if no ID is set, assume the database has just been initialized */
562	rv = cache_get_master_entry(&cache_master_entry);	563	rv = cache_get_master_entry(&cache_master_entry);
563	if (rv == DB_NOTFOUND) {	564	if (rv == MDB_NOTFOUND) {
564	cache_get_int("notifier_id", &cache_master_entry.id, -1);	565	cache_get_int("notifier_id", &cache_master_entry.id, -1);
565	if (cache_master_entry.id == -1) {	566	if (cache_master_entry.id == -1) {
566	rv = notifier_get_id_s(NULL, &cache_master_entry.id);	567	rv = notifier_get_id_s(NULL, &cache_master_entry.id);




	char		*bindpw = NULL;
	char		*basedn = NULL;
	int		 rv;
	MDB_cursor	*id2entry_read_cursor_p = NULL;
	MDB_cursor	*id2dn_read_cursor_p = NULL;
	char		*dn;
	CacheEntry	 entry;
	LDAP		*ld;

	}


	if (cache_init(MDB_RDONLY) != 0)
		exit(1);

	for (rv=cache_first_entry(&id2entry_read_cursor_p, &id2dn_read_cursor_p, &dn, &entry); rv != MDB_NOTFOUND;
			rv=cache_next_entry(&id2entry_read_cursor_p, &id2dn_read_cursor_p, &dn, &entry)) {
		if (rv < -1) break;

		if (has_dn(dn)) {

		}
		add_dn(dn);
	}
	cache_free_cursor(id2entry_read_cursor_p, id2dn_read_cursor_p);

	if ((rv=ldap_search_ext_s(ld, basedn, LDAP_SCOPE_SUBTREE, "(objectClass=*)",
			attrs, attrsonly0, serverctrls, clientctrls, &timeout, sizelimit0, &res)) != LDAP_SUCCESS) {

			char *dn = ldap_get_dn(ld, cur);
			if (has_dn(dn)) continue;

			if ((rv = cache_get_entry(dn, &entry)) == MDB_NOTFOUND) {
				printf("E: %s only in LDAP\n", dn);
			} else if (rv != 0) {
				printf("E: error reading %s from cache", dn);

Return to bug 23367

Lines 67-72 fi Link Here

(-)a/management/univention-directory-listener/debian/univention-directory-listener.postinst (+31 lines)
67		67
68	call_joinscript 03univention-directory-listener.inst	68	call_joinscript 03univention-directory-listener.inst
69		69
		70	convert_to_lmdb() {
		71	if [ ! -f /var/lib/univention-directory-listener/cache/data.mdb ]; then
		72	if [ ! -d /var/lib/univention-directory-listener/cache ]; then
		73	mkdir /var/lib/univention-directory-listener/cache
		74	fi
		75	if [ -f /var/lib/univention-directory-listener/cache.db ]; then
		76	running=1
		77	/etc/init.d/univention-directory-listener status >/dev/null \
		78	&& running=1 \|\| running=0
		79
		80	if [ "$running" -eq 1 ]; then
		81	/etc/init.d/univention-directory-listener stop
		82	fi
		83
		84	univention-directory-listener-convert \
		85	/var/lib/univention-directory-listener/cache.db
		86
		87	chown -R listener.nogroup \
		88	/var/lib/univention-directory-listener/cache
		89
		90	if [ "$running" -eq 1 ]; then
		91	/etc/init.d/univention-directory-listener start
		92	fi
		93	fi
		94	fi
		95	}
70		96
71	if [ "$1" = "configure" -a -n "$2" ]; then	97	if [ "$1" = "configure" -a -n "$2" ]; then
72	if dpkg --compare-versions "$2" lt 6.0.7 && dpkg --compare-versions "$2" gt 6.0.0; then	98	if dpkg --compare-versions "$2" lt 6.0.7 && dpkg --compare-versions "$2" gt 6.0.0; then
Lines 76-81 if [ "$1" = "configure" -a -n "$2" ]; then Link Here
76	mv /var/lib/univention-directory-listener/__* /var/univention-backup/listener-cache-ucs_3.0-ms1/	102	mv /var/lib/univention-directory-listener/__* /var/univention-backup/listener-cache-ucs_3.0-ms1/
77	mv /var/lib/univention-directory-listener/log.* /var/univention-backup/listener-cache-ucs_3.0-ms1/	103	mv /var/lib/univention-directory-listener/log.* /var/univention-backup/listener-cache-ucs_3.0-ms1/
78	fi	104	fi
		105
		106	if dpkg --compare-versions "$2" lt 11.0.0-7; then
		107	convert_to_lmdb
		108	fi
		109
79	/etc/init.d/univention-directory-listener crestart	110	/etc/init.d/univention-directory-listener crestart
80	fi	111	fi
81		112

Lines 40-46 Link Here

(-)a/management/univention-directory-listener/src/change.c (-11 / +11 lines)
40	#include <stdlib.h>	40	#include <stdlib.h>
41	#include <stdbool.h>	41	#include <stdbool.h>
42	#include <string.h>	42	#include <string.h>
43	#include <db.h>	43	#include <lmdb.h>
44		44
45	#include <univention/debug.h>	45	#include <univention/debug.h>
46	#include <univention/config.h>	46	#include <univention/config.h>
Lines 74-80 static int change_init_module(univention_ldap_parameters_t lp, Handler handler Link Here
74	struct filter **f;	74	struct filter **f;
75	int rv;	75	int rv;
76	CacheEntry cache_entry, old_cache_entry;	76	CacheEntry cache_entry, old_cache_entry;
77	DBC *dbc_cur;	77	MDB_cursor *id2entry_read_cursor_p = NULL;
		78	MDB_cursor *id2dn_read_cursor_p = NULL;
78	char *dn = NULL;	79	char *dn = NULL;
79	int i;	80	int i;
80	bool abort_init = false;	81	bool abort_init = false;
Lines 93-118 static int change_init_module(univention_ldap_parameters_t lp, Handler handler Link Here
93	/* remove old entries for module */	94	/* remove old entries for module */
94	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_INFO,	95	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_INFO,
95	"remove old entries for module %s", handler->name);	96	"remove old entries for module %s", handler->name);
96	for (rv=cache_first_entry(&dbc_cur, &dn, &cache_entry); rv != DB_NOTFOUND;	97	for (rv=cache_first_entry(&id2entry_read_cursor_p, &id2dn_read_cursor_p, &dn, &cache_entry); rv != MDB_NOTFOUND;
97	rv=cache_next_entry(&dbc_cur, &dn, &cache_entry)) {	98	rv=cache_next_entry(&id2entry_read_cursor_p, &id2dn_read_cursor_p, &dn, &cache_entry)) {
98	if (rv == -1) continue;	99	if (rv == -1) continue;
99	if (rv < 0) break;	100	if (rv < 0) break;
100		101
101	cache_entry_module_remove(&cache_entry, handler->name);	102	cache_entry_module_remove(&cache_entry, handler->name);
102	cache_update_or_deleteifunused_entry(0, dn, &cache_entry);	103	cache_update_or_deleteifunused_entry(0, dn, &cache_entry, &id2dn_read_cursor_p);
103	cache_free_entry(&dn, &cache_entry);	104	cache_free_entry(&dn, &cache_entry);
104	}	105	}
105		106
106	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_INFO,	107	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_INFO,
107	"call cache_free_cursor for module %s", handler->name);	108	"call cache_free_cursor for module %s", handler->name);
108	cache_free_cursor(dbc_cur);	109	cache_free_cursor(id2entry_read_cursor_p, id2dn_read_cursor_p);
109		110
110	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_INFO,	111	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_INFO,
111	"initialize schema for module %s", handler->name);	112	"initialize schema for module %s", handler->name);
112	/* initialize schema; if it's not in cache yet (it really should be), it'll	113	/* initialize schema; if it's not in cache yet (it really should be), it'll
113	be initialized on the regular schema check after ldapsearches */	114	be initialized on the regular schema check after ldapsearches */
114	if ((rv = cache_get_entry_lower_upper("cn=Subschema", &cache_entry)) != 0 &&	115	if ((rv = cache_get_entry_lower_upper("cn=Subschema", &cache_entry)) != 0 &&
115	rv != DB_NOTFOUND) {	116	rv != MDB_NOTFOUND) {
116	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_WARN,	117	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_WARN,
117	"error while reading from database");	118	"error while reading from database");
118	return LDAP_OTHER;	119	return LDAP_OTHER;
Lines 184-190 static int change_init_module(univention_ldap_parameters_t lp, Handler handler Link Here
184	for (i=0; i<dn_count; i++) {	185	for (i=0; i<dn_count; i++) {
185	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "DN: %s", dns[i].dn);	186	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "DN: %s", dns[i].dn);
186		187
187	if ((rv = cache_get_entry_lower_upper(dns[i].dn, &cache_entry)) == DB_NOTFOUND) { /* XXX */	188	if ((rv = cache_get_entry_lower_upper(dns[i].dn, &cache_entry)) == MDB_NOTFOUND) { /* XXX */
188	LDAPMessage res2, first;	189	LDAPMessage res2, first;
189	int attrsonly0 = 0;	190	int attrsonly0 = 0;
190	rv = LDAP_RETRY(lp, ldap_search_ext_s(lp->ld, dns[i].dn, LDAP_SCOPE_BASE, "(objectClass=*)", attrs, attrsonly0, serverctrls, clientctrls, &timeout, sizelimit0, &res2));	191	rv = LDAP_RETRY(lp, ldap_search_ext_s(lp->ld, dns[i].dn, LDAP_SCOPE_BASE, "(objectClass=*)", attrs, attrsonly0, serverctrls, clientctrls, &timeout, sizelimit0, &res2));
Lines 246-252 int change_new_modules(univention_ldap_parameters_t *lp) Link Here
246	}	247	}
247	}	248	}
248	INIT_ONLY = old_init_only;	249	INIT_ONLY = old_init_only;
249	cache_sync();
250		250
251	return 0;	251	return 0;
252	}	252	}
Lines 267-273 int change_update_entry(univention_ldap_parameters_t *lp, NotifierID id, LDAPMes Link Here
267	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_WARN, "error while converting LDAP entry to cache entry");	267	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_WARN, "error while converting LDAP entry to cache entry");
268	goto result;	268	goto result;
269	}	269	}
270	if ((rv = cache_get_entry_lower_upper(dn, &old_cache_entry)) != 0 && rv != DB_NOTFOUND) {	270	if ((rv = cache_get_entry_lower_upper(dn, &old_cache_entry)) != 0 && rv != MDB_NOTFOUND) {
271	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_WARN, "error while reading from database");	271	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_WARN, "error while reading from database");
272	rv = LDAP_OTHER;	272	rv = LDAP_OTHER;
273	} else {	273	} else {
Lines 694-700 int change_update_dn(struct transaction *trans) { Link Here
694	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_PROCESS, "updating '%s' command %c", trans->cur.notify.dn, trans->cur.notify.command);	694	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_PROCESS, "updating '%s' command %c", trans->cur.notify.dn, trans->cur.notify.command);
695		695
696	rv = cache_get_entry_lower_upper(trans->cur.notify.dn, &trans->cur.cache);	696	rv = cache_get_entry_lower_upper(trans->cur.notify.dn, &trans->cur.cache);
697	if (rv != 0 && rv != DB_NOTFOUND) {	697	if (rv != 0 && rv != MDB_NOTFOUND) {
698	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_WARN, "error reading database for %s", trans->cur.notify.dn);	698	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_WARN, "error reading database for %s", trans->cur.notify.dn);
699	return LDAP_OTHER;	699	return LDAP_OTHER;
700	}	700	}

Lines 67-73 int main(int argc, char* argv[]) Link Here

(-)a/management/univention-directory-listener/src/dump.c (-5 / +6 lines)
67	char *output_file = NULL;	67	char *output_file = NULL;
68	FILE *fp;	68	FILE *fp;
69	int rv;	69	int rv;
70	DBC *cur;	70	MDB_cursor *id2entry_read_cursor_p = NULL;
		71	MDB_cursor *id2dn_read_cursor_p = NULL;
71	char *dn = NULL;	72	char *dn = NULL;
72	CacheEntry entry;	73	CacheEntry entry;
73		74
Lines 124-130 int main(int argc, char* argv[]) Link Here
124	"Couldn't open dump file");	125	"Couldn't open dump file");
125	exit(1);	126	exit(1);
126	}	127	}
127	if (cache_init() != 0)	128	if (cache_init(MDB_RDONLY) != 0)
128	exit(1);	129	exit(1);
129		130
130	if (id_only) {	131	if (id_only) {
Lines 133-140 int main(int argc, char* argv[]) Link Here
133	printf("%ld %ld\n", cache_master_entry.id, cache_master_entry.schema_id);	134	printf("%ld %ld\n", cache_master_entry.id, cache_master_entry.schema_id);
134	} else {	135	} else {
135		136
136	for (rv=cache_first_entry(&cur, &dn, &entry); rv != DB_NOTFOUND;	137	for (rv=cache_first_entry(&id2entry_read_cursor_p, &id2dn_read_cursor_p, &dn, &entry); rv != MDB_NOTFOUND;
137	rv=cache_next_entry(&cur, &dn, &entry)) {	138	rv=cache_next_entry(&id2entry_read_cursor_p, &id2dn_read_cursor_p, &dn, &entry)) {
138	if ((rv == 0 && !broken_only) \|\| (rv == -1 && broken_only)) {	139	if ((rv == 0 && !broken_only) \|\| (rv == -1 && broken_only)) {
139	cache_dump_entry(dn, &entry, fp);	140	cache_dump_entry(dn, &entry, fp);
140	fprintf(fp, "\n");	141	fprintf(fp, "\n");
Lines 142-148 int main(int argc, char* argv[]) Link Here
142	cache_free_entry(&dn, &entry);	143	cache_free_entry(&dn, &entry);
143	if (rv < -1) break;	144	if (rv < -1) break;
144	}	145	}
145	cache_free_cursor(cur);	146	cache_free_cursor(id2entry_read_cursor_p, id2dn_read_cursor_p);
146		147
147	}	148	}
148		149

Lines 140-146 int main(int argc, char* argv[]) Link Here

(-)a/management/univention-directory-listener/src/verify.c (-6 / +7 lines)
140	char *bindpw = NULL;	140	char *bindpw = NULL;
141	char *basedn = NULL;	141	char *basedn = NULL;
142	int rv;	142	int rv;
143	DBC *cur;	143	MDB_cursor *id2entry_read_cursor_p = NULL;
		144	MDB_cursor *id2dn_read_cursor_p = NULL;
144	char *dn;	145	char *dn;
145	CacheEntry entry;	146	CacheEntry entry;
146	LDAP *ld;	147	LDAP *ld;
Lines 221-231 int main(int argc, char* argv[]) Link Here
221	}	222	}
222		223
223		224
224	if (cache_init() != 0)	225	if (cache_init(MDB_RDONLY) != 0)
225	exit(1);	226	exit(1);
226		227
227	for (rv=cache_first_entry(&cur, &dn, &entry); rv != DB_NOTFOUND;	228	for (rv=cache_first_entry(&id2entry_read_cursor_p, &id2dn_read_cursor_p, &dn, &entry); rv != MDB_NOTFOUND;
228	rv=cache_next_entry(&cur, &dn, &entry)) {	229	rv=cache_next_entry(&id2entry_read_cursor_p, &id2dn_read_cursor_p, &dn, &entry)) {
229	if (rv < -1) break;	230	if (rv < -1) break;
230		231
231	if (has_dn(dn)) {	232	if (has_dn(dn)) {
Lines 245-251 int main(int argc, char* argv[]) Link Here
245	}	246	}
246	add_dn(dn);	247	add_dn(dn);
247	}	248	}
248	cache_free_cursor(cur);	249	cache_free_cursor(id2entry_read_cursor_p, id2dn_read_cursor_p);
249		250
250	if ((rv=ldap_search_ext_s(ld, basedn, LDAP_SCOPE_SUBTREE, "(objectClass=*)",	251	if ((rv=ldap_search_ext_s(ld, basedn, LDAP_SCOPE_SUBTREE, "(objectClass=*)",
251	attrs, attrsonly0, serverctrls, clientctrls, &timeout, sizelimit0, &res)) != LDAP_SUCCESS) {	252	attrs, attrsonly0, serverctrls, clientctrls, &timeout, sizelimit0, &res)) != LDAP_SUCCESS) {
Lines 258-264 int main(int argc, char* argv[]) Link Here
258	char *dn = ldap_get_dn(ld, cur);	259	char *dn = ldap_get_dn(ld, cur);
259	if (has_dn(dn)) continue;	260	if (has_dn(dn)) continue;
260		261
261	if ((rv = cache_get_entry(dn, &entry)) == DB_NOTFOUND) {	262	if ((rv = cache_get_entry(dn, &entry)) == MDB_NOTFOUND) {
262	printf("E: %s only in LDAP\n", dn);	263	printf("E: %s only in LDAP\n", dn);
263	} else if (rv != 0) {	264	} else if (rv != 0) {
264	printf("E: error reading %s from cache", dn);	265	printf("E: error reading %s from cache", dn);

Lines 31-43 Link Here

(-)a/management/univention-directory-listener/src/Makefile (-6 / +13 lines)
31	#	31	#
32	CC ?= gcc	32	CC ?= gcc
33		33
34	DB_LDLIBS := -ldb3	34	DB_LDLIBS := -llmdb
35	DB_CFLAGS := -I/usr/include/db3 -DWITH_DB3	35	DB_OBJS := cache.o cache_dn.o cache_entry.o cache_lowlevel.o base64.o filter.o
36	DB_OBJS := cache.o cache_entry.o cache_lowlevel.o base64.o filter.o
37		36
38	LDAP_LDLIBS := -lldap -llber	37	LDAP_LDLIBS := -lldap -llber
39		38
40	CFLAGS += -Wall -Werror -D_FILE_OFFSET_BITS=64 $(DB_CFLAGS)	39	CFLAGS += -Wall -Werror -D_FILE_OFFSET_BITS=64
41	LDLIBS := -luniventiondebug -luniventionconfig -licuuc	40	LDLIBS := -luniventiondebug -luniventionconfig -licuuc
42	LISTENER_LDLIBS := -luniventionpolicy $(LDAP_LDLIBS) -lpython2.7 $(DB_LDLIBS)	41	LISTENER_LDLIBS := -luniventionpolicy $(LDAP_LDLIBS) -lpython2.7 $(DB_LDLIBS)
43	LISTENER_OBJS := main.o notifier.o transfile.o handlers.o change.o network.o signals.o select_server.o utils.o $(DB_OBJS)	42	LISTENER_OBJS := main.o notifier.o transfile.o handlers.o change.o network.o signals.o select_server.o utils.o $(DB_OBJS)
Lines 46-54 DUMP_OBJS := dump.o dump_signals.o utils.o $(DB_OBJS) Link Here
46	DEMO_OBJS := demo.o network.o utils.o	45	DEMO_OBJS := demo.o network.o utils.o
47	VERIFY_LDLIBS := $(LDAP_LDLIBS) $(DB_LDLIBS)	46	VERIFY_LDLIBS := $(LDAP_LDLIBS) $(DB_LDLIBS)
48	VERIFY_OBJS := verify.o dump_signals.o utils.o $(DB_OBJS)	47	VERIFY_OBJS := verify.o dump_signals.o utils.o $(DB_OBJS)
		48	CONVERT_LDLIBS := $(LDAP_LDLIBS) $(DB_LDLIBS) -ldb3
		49	CONVERT_OBJS := convert.o cache_bdb.o dump_signals.o utils.o $(DB_OBJS)
49		50
50	.PHONY: all	51	.PHONY: all
51	all: listener dump verify	52	all: listener dump verify convert
52		53
53	listener: $(LISTENER_OBJS)	54	listener: $(LISTENER_OBJS)
54	$(CC) $(LDFLAGS) -o $@ $^ $(LDLIBS) $(LISTENER_LDLIBS)	55	$(CC) $(LDFLAGS) -o $@ $^ $(LDLIBS) $(LISTENER_LDLIBS)
Lines 62-67 demo: $(DEMO_OBJS) Link Here
62	verify: $(VERIFY_OBJS)	63	verify: $(VERIFY_OBJS)
63	$(CC) $(LDFLAGS) -o $@ $^ $(LDLIBS) $(VERIFY_LDLIBS)	64	$(CC) $(LDFLAGS) -o $@ $^ $(LDLIBS) $(VERIFY_LDLIBS)
64		65
		66	convert: $(CONVERT_OBJS)
		67	$(CC) $(LDFLAGS) -o $@ $^ $(LDLIBS) $(CONVERT_LDLIBS)
		68
		69	cache_bdb.o: cache_bdb.c
		70	$(CC) $(CFLAGS) -I/usr/include/db3 -DWITH_DB3 -c $^
		71
65	.PHONY: clean	72	.PHONY: clean
66	clean:	73	clean:
67	$(RM) .o listener dump demo verify .db3 *.db42	74	$(RM) .o listener dump demo verify convert .db3 *.db42

Lines 33-39 Link Here

(-)a/management/univention-directory-listener/src/cache.h (-8 / +12 lines)
33	#ifndef _CACHE_H_	33	#ifndef _CACHE_H_
34	#define _CACHE_H_	34	#define _CACHE_H_
35		35
36	#include <db.h>	36	#include <lmdb.h>
37		37
38	#include "network.h"	38	#include "network.h"
39	#include "cache_entry.h"	39	#include "cache_entry.h"
Lines 49-59 typedef struct _CacheMasterEntry { Link Here
49	extern CacheMasterEntry cache_master_entry;	49	extern CacheMasterEntry cache_master_entry;
50		50
51	int cache_lock(void);	51	int cache_lock(void);
52	int cache_init (void);	52	int cache_init (int mdb_flags);
53	void cache_sync(void);	53	void cache_sync(void);
54	int cache_get_master_entry (CacheMasterEntry *master_entry);	54	int cache_get_master_entry (CacheMasterEntry *master_entry);
55	int cache_update_master_entry (CacheMasterEntry *master_entry,	55	int cache_update_master_entry (CacheMasterEntry *master_entry,
56	DB_TXN *dptxnp);	56	MDB_txn *dptxnp);
57	int cache_update_entry (NotifierID id,	57	int cache_update_entry (NotifierID id,
58	char *dn,	58	char *dn,
59	CacheEntry *entry);	59	CacheEntry *entry);
Lines 66-86 int cache_delete_entry_lower_upper (NotifierID id, Link Here
66	char *dn);	66	char *dn);
67	int cache_update_or_deleteifunused_entry (NotifierID id,	67	int cache_update_or_deleteifunused_entry (NotifierID id,
68	char *dn,	68	char *dn,
69	CacheEntry *entry);	69	CacheEntry *entry,
		70	MDB_cursor **cur);
70	int cache_get_entry(	71	int cache_get_entry(
71	char *dn,	72	char *dn,
72	CacheEntry *entry);	73	CacheEntry *entry);
73	int cache_get_entry_lower_upper(	74	int cache_get_entry_lower_upper(
74	char *dn,	75	char *dn,
75	CacheEntry *entry);	76	CacheEntry *entry);
76	int cache_first_entry (DBC **cur,	77	int cache_first_entry (MDB_cursor **cur,
		78	MDB_cursor **cur_dn,
77	char **dn,	79	char **dn,
78	CacheEntry *entry);	80	CacheEntry *entry);
79	int cache_next_entry (DBC **cur,	81	int cache_next_entry (MDB_cursor **cur,
		82	MDB_cursor **cur_dn,
80	char **dn,	83	char **dn,
81	CacheEntry *entry);	84	CacheEntry *entry);
82	int cache_free_cursor (DBC *cur);	85	int cache_free_cursor (MDB_cursor *cur,
83	int cache_close (void);	86	MDB_cursor *cur_dn);
		87	void cache_close (void);
84		88
85	/* deprecated with DB42*/	89	/* deprecated with DB42*/
86	int cache_set_int (char *key,	90	int cache_set_int (char *key,

Line 0 Link Here

(-)a/management/univention-directory-listener/src/cache_bdb.c (+722 lines)
		1	/*
		2	* Univention Directory Listener
		3	* ldap listener caching system
		4	*
		5	* Copyright 2004-2017 Univention GmbH
		6	*
		7	* http://www.univention.de/
		8	*
		9	* All rights reserved.
		10	*
		11	* The source code of this program is made available
		12	* under the terms of the GNU Affero General Public License version 3
		13	* (GNU AGPL V3) as published by the Free Software Foundation.
		14	*
		15	* Binary versions of this program provided by Univention to you as
		16	* well as other copyrighted, protected or trademarked materials like
		17	* Logos, graphics, fonts, specific documentations and configurations,
		18	* cryptographic keys etc. are subject to a license agreement between
		19	* you and Univention and not subject to the GNU AGPL V3.
		20	*
		21	* In the case you use this program under the terms of the GNU AGPL V3,
		22	* the program is provided in the hope that it will be useful,
		23	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		24	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		25	* GNU Affero General Public License for more details.
		26	*
		27	* You should have received a copy of the GNU Affero General Public
		28	* License with the Debian GNU/Linux or Univention distribution in file
		29	* /usr/share/common-licenses/AGPL-3; if not, see
		30	* <http://www.gnu.org/licenses/>.
		31	*/
		32
		33	/* How it works:
		34
		35	LDAP entries are cached here. If a modification takes place,
		36	the new LDAP entry is compared with the cache entry, and both,
		37	old and new entries, are passed to the handler modules.
		38
		39	Berkeley DB provides a way to store and receive a chunk of data
		40	with a given key. However, we're not working with cache entries
		41	as chunks of data later, but use C structures. So we'll need to
		42	convert the C structure we can work with to chunks of data we
		43	can store in BDB, and the other way around.
		44
		45	We have decided on a pretty low level, but straightforward
		46	binary format for the chunk of data. For manual error recovery, a
		47	text-based format like LDIF might have been easier.
		48
		49	The function unparse_entry converts a C structure entry to a data
		50	chunk, parse_entry does the opposite.
		51
		52	To convert the entry, unparse_entry walks through all values of
		53	all attributes, as well as through the list of modules registered
		54	with it, and write a block for each (attribute, value) pair or
		55	(, module) [write_header]. Each block starts with an entry_header
		56	structure that specified the lengths of the following data.
		57	*/
		58
		59
		60	#define _GNU_SOURCE /* for strndup */
		61
		62	#include <stdlib.h>
		63	#include <string.h>
		64	#include <limits.h>
65	#include <unistd.h>
66	#include <ctype.h>
67	#include <sys/types.h>
68	#include <sys/file.h>
69	#include <sys/stat.h>
70	#include <db.h>
71	#include <stdbool.h>
72	#include <assert.h>
73
74	#include <univention/debug.h>
75	#include <univention/config.h>
76
77	#include "common.h"
78	#include "cache_bdb.h"
79	#include "cache_lowlevel.h"
80	#include "cache_entry.h"
81	#include "network.h"
82	#include "signals.h"
83	#include "filter.h"
84	#include "utils.h"
85
86	#define MASTER_KEY "__master__"
87	#define MASTER_KEY_SIZE (sizeof MASTER_KEY)
88
89	char *bdb_cache_dir = "/var/lib/univention-directory-listener";
90	char *bdb_ldap_dir = "/var/lib/univention-ldap";
91
92	BdbCacheMasterEntry bdb_cache_master_entry;
93
94	DB *dbp;
95	#ifdef WITH_DB42
96	DB_ENV *dbenvp;
97	#endif
98	static FILE *lock_fp=NULL;
99
100	static struct filter cache_filter;
101	static struct filter *cache_filters[] = {&cache_filter, NULL};
102
103	static void setup_cache_filter(void) {
104	FREE(cache_filter.filter);
105	FREE(cache_filter.base);
106	cache_filter.filter = univention_config_get_string("listener/cache/filter");
107	if (cache_filter.filter && cache_filter.filter[0]) {
108	cache_filter.base = univention_config_get_string("ldap/base");
109	cache_filter.scope = LDAP_SCOPE_SUBTREE;
110	}
111	}
112
113	#ifdef WITH_DB42
114	static void bdb_cache_panic_call(DB_ENV *dbenvp, int errval)
115	{
116	exit(1);
117	}
118	#endif
119
120	static void bdb_cache_error_message(const char errpfx, char msg)
121	{
122	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
123	"database error: %s", msg);
124	}
125
126	int bdb_cache_lock(void)
127	{
128	int rv, fd;
129	char lock_file[PATH_MAX];
130
131	assert(!lock_fp);
132
133	rv = snprintf(lock_file, PATH_MAX, "%s/cache.db.lock", bdb_cache_dir);
134	if (rv < 0 \|\| rv >= PATH_MAX)
135	abort();
136
137	if ((lock_fp = fopen(lock_file, "a+e")) == NULL) {
138	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
139	"Could not open lock file [%s]", lock_file);
140	exit(EXIT_FAILURE);
141	}
142	fd = fileno(lock_fp);
143
144	if (lockf(fd, F_TLOCK, 0) != 0) {
145	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
146	"Could not get lock for database [%s]; "
147	"Is another listener processs running?\n",
148	lock_file);
149	exit(EXIT_FAILURE);
150	}
151
152	return fd;
153	}
154
155	int bdb_cache_init(void)
156	{
157	int rv;
158	char file[PATH_MAX];
159
160	snprintf(file, PATH_MAX, "%s/cache.db", bdb_cache_dir);
161
162	#ifdef WITH_DB42
163	if ((rv = db_env_create(&dbenvp, 0)) != 0) {
164	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
165	"creating database environment failed");
166	return rv;
167	}
168	dbenvp->set_errcall(dbenvp, bdb_cache_error_message);
169	dbenvp->set_paniccall(dbenvp, bdb_cache_panic_call);
170	if ((rv = dbenvp->open(dbenvp, bdb_cache_dir, DB_CREATE \| DB_INIT_MPOOL \|
171	/DB_INIT_LOCK \| /DB_INIT_LOG \| DB_INIT_TXN \|
172	DB_RECOVER, 0600)) != 0) {
173	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
174	"opening database environment failed");
175	dbenvp->err(dbenvp, rv, "%s", "environment");
176	return rv;
177	}
178	if ((rv = db_create(&dbp, dbenvp, 0)) != 0) {
179	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
180	"creating database handle failed");
181	return rv;
182	}
183	if ((rv = dbp->open(dbp, NULL, "cache.db", NULL, DB_BTREE,
184	DB_CREATE \| DB_CHKSUM \| DB_AUTO_COMMIT,
185	0600)) != 0) {
186	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
187	"opening database failed");
188	dbp->err(dbp, rv, "open");
189	// FIXME: free dbp
190	return rv;
191	}
192	#else
193	if ((rv = db_create(&dbp, NULL, 0)) != 0) {
194	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
195	"creating database handle failed");
196	return rv;
197	}
198	if ((rv = dbp->open(dbp, file, NULL, DB_BTREE, DB_CREATE, 0600)) != 0) {
199	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
200	"opening database failed");
201	dbp->err(dbp, rv, "open");
202	// FIXME: free dbp
203	return rv;
204	}
205	dbp->set_errcall(dbp, bdb_cache_error_message);
206	#endif
207	setup_cache_filter();
208	return 0;
209	}
210
211	void bdb_cache_sync(void) {
212	if (dbp) {
213	dbp->sync(dbp, 0);
214	}
215	}
216
217	int bdb_cache_set_schema_id(const NotifierID value)
218	{
219	int rv, fd, len;
220	char file[PATH_MAX], buf[15];
221
222	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_WARN, "Set Schema ID to %ld", value);
223	len = snprintf(buf, sizeof buf, "%ld", value);
224	if (len < 0 \|\| len >= sizeof buf)
225	return len;
226
227	rv = snprintf(file, PATH_MAX, "%s/schema/id/id", bdb_ldap_dir);
228	if (rv < 0 \|\| rv >= PATH_MAX)
229	return rv;
230	fd = open(file, O_WRONLY \| O_CREAT, 0644);
231	if (fd < 0)
232	return fd;
233	rv = write(fd, buf, len);
234	if (rv != len) {
235	close(fd);
236	return 1;
237	}
238	rv = ftruncate(fd, len);
239	if (rv != 0)
240	return rv;
241	rv = close(fd);
242	if (rv != 0)
243	return rv;
244	return 0;
245	}
246
247	int bdb_cache_get_schema_id(NotifierID *value, const long def)
248	{
249	FILE *fp;
250	char file[PATH_MAX];
251	int rv;
252
253	*value = def;
254
255	snprintf(file, PATH_MAX, "%s/schema/id/id", bdb_ldap_dir);
256	if ((fp = fopen(file, "r")) == NULL)
257	return 1;
258	rv = fscanf(fp, "%ld", value);
259	return fclose(fp) \|\| (rv != 1);
260	}
261
262	int bdb_cache_set_int(char *key, const NotifierID value)
263	{
264	int rv;
265	FILE *fp;
266	char file[PATH_MAX], tmpfile[PATH_MAX];
267
268	rv = snprintf(tmpfile, PATH_MAX, "%s/%s.tmp", bdb_cache_dir, key);
269	if (rv < 0 \|\| rv >= PATH_MAX)
270	return rv;
271	if ((fp = fopen(tmpfile, "w")) == NULL)
272	abort_io("open", tmpfile);
273	fprintf(fp, "%ld", value);
274	rv = fclose(fp);
275	if (rv != 0)
276	abort_io("close", tmpfile);
277
278	rv = snprintf(file, PATH_MAX, "%s/%s", bdb_cache_dir, key);
279	if (rv < 0 \|\| rv >= PATH_MAX)
280	return rv;
281	rv = rename(tmpfile, file);
282	return rv;
283	}
284
285	int bdb_cache_get_int(char key, NotifierID value, const long def)
286	{
287	FILE *fp;
288	char file[PATH_MAX];
289	int rv;
290
291	*value = def;
292
293	snprintf(file, PATH_MAX, "%s/%s", bdb_cache_dir, key);
294	if ((fp = fopen(file, "r")) == NULL)
295	return 1;
296	rv = fscanf(fp, "%ld", value);
297	return fclose(fp) \|\| (rv != 1);
298	}
299
300	int bdb_cache_get_master_entry(BdbCacheMasterEntry *master_entry)
301	{
302	DBT key, data;
303	int rv;
304
305	memset(&key, 0, sizeof(DBT));
306	memset(&data, 0, sizeof(DBT));
307
308	key.data=MASTER_KEY;
309	key.size=MASTER_KEY_SIZE;
310	data.flags = DB_DBT_REALLOC;
311
312	if ((rv=dbp->get(dbp, NULL, &key, &data, 0)) == DB_NOTFOUND)
313	return rv;
314	else if (rv != 0) {
315	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
316	"reading master entry from database failed");
317	dbp->err(dbp, rv, "get");
318	return rv;
319	}
320
321	if (data.size != sizeof(BdbCacheMasterEntry)) {
322	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
323	"master entry has unexpected length");
324	return 1;
325	}
326
327	memcpy(master_entry, data.data, sizeof(BdbCacheMasterEntry));
328	free(data.data);
329
330	return 0;
331	}
332
333	int bdb_cache_update_master_entry(BdbCacheMasterEntry master_entry, DB_TXN dbtxnp)
334	{
335	DBT key, data;
336	int rv;
337	int flags;
338
339	memset(&key, 0, sizeof(DBT));
340	memset(&data, 0, sizeof(DBT));
341
342	key.data=MASTER_KEY;
343	key.size=MASTER_KEY_SIZE;
344
345	data.data=(void*)master_entry;
346	data.size=sizeof(BdbCacheMasterEntry);
347
348	#ifdef WITH_DB42
349	if (dbtxnp == NULL)
350	flags = DB_AUTO_COMMIT;
351	else
352	#endif
353	flags = 0;
354
355	if ((rv=dbp->put(dbp, dbtxnp, &key, &data, flags)) != 0) {
356	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
357	"storing master entry in database failed");
358	dbp->err(dbp, rv, "put");
359	return rv;
360	}
361
362	bdb_cache_sync();
363
364	return 0;
365	}
366
367	DB_TXN* bdb_cache_new_transaction(NotifierID id, char *dn)
368	{
369	#ifdef WITH_DB42
370	DB_TXN *dbtxnp;
371	BdbCacheMasterEntry master_entry;
372	NotifierID *old_id;
373
374	dbenvp->txn_begin(dbenvp, NULL, &dbtxnp, 0);
375
376	if (id != 0) {
377	if (bdb_cache_get_master_entry(&master_entry) != 0) {
378	dbtxnp->abort(dbtxnp);
379	return NULL;
380	}
381
382	if (strcmp(dn, "cn=Subschema") == 0)
383	old_id = &master_entry.schema_id;
384	else
385	old_id = &master_entry.id;
386
387	if (*old_id >= id) {
388	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
389	"New ID (%ld) is not greater than old"
390	" ID (%ld): %s", id, *old_id, dn);
391	dbtxnp->abort(dbtxnp);
392	return NULL;
393	} else
394	*old_id = id;
395
396	if (bdb_cache_update_master_entry(&master_entry, dbtxnp) != 0) {
397	dbtxnp->abort(dbtxnp);
398	return NULL;
399	}
400	}
401
402	return dbtxnp;
403	#else
404	return NULL;
405	#endif
406	}
407
408
409	/* XXX: The NotifierID is passed for future use. Once the journal is
410	implemented, entries other than the most recent one can be returned.
411	At the moment, the id parameters for bdb_cache_update_entry, and
412	bdb_cache_delete_entry do nothing (at least if WITH_DB42 is undefined) */
413	inline int bdb_cache_update_entry(NotifierID id, char dn, CacheEntry entry)
414	{
415	DBT key, data;
416	DB_TXN *dbtxnp;
417	int rv = 0;
418
419	memset(&key, 0, sizeof(DBT));
420	memset(&data, 0, sizeof(DBT));
421
422	if ((rv=unparse_entry(&data.data, &data.size, entry)) != 0) {
423	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
424	"unparsing entry failed");
425	return rv;
426	}
427
428
429	signals_block();
430	#ifdef WITH_DB42
431	dbtxnp = bdb_cache_new_transaction(id, dn);
432	if (dbtxnp == NULL) {
433	signals_unblock();
434	free(data.data);
435	return 1;
436	}
437	#else
438	dbtxnp = NULL;
439	#endif
440
441	key.data=dn;
442	key.size=strlen(dn)+1;
443
444	if ((rv=dbp->put(dbp, dbtxnp, &key, &data, 0)) != 0) {
445	signals_unblock();
446	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
447	"storing entry in database failed: %s", dn);
448	dbp->err(dbp, rv, "put");
449	#ifdef WITH_DB42
450	dbtxnp->abort(dbtxnp);
451	#endif
452	free(data.data);
453	return rv;
454	}
455	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "put %d bytes for %s", data.size, dn);
456
457
458	#ifdef WITH_DB42
459	dbtxnp->commit(dbtxnp, 0);
460	#endif
461	bdb_cache_sync();
462	signals_unblock();
463
464	free(data.data);
465	return rv;
466	}
467
468	int bdb_cache_update_entry_lower(NotifierID id, char dn, CacheEntry entry)
469	{
470	char *lower_dn;
471	int rv = 0;
472
473	if (cache_filter.filter && cache_entry_ldap_filter_match(cache_filters, dn, entry)) {
474	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "Not caching %s, filtered out.", dn);
475	return rv;
476	}
477
478	lower_dn = lower_utf8(dn);
479	rv = bdb_cache_update_entry(id, lower_dn, entry);
480
481	free(lower_dn);
482	return rv;
483	}
484
485	int bdb_cache_delete_entry(NotifierID id, char *dn)
486	{
487	DB_TXN *dbtxnp;
488	DBT key;
489	int rv;
490
491	memset(&key, 0, sizeof(DBT));
492
493	key.data=dn;
494	key.size=strlen(dn)+1;
495
496	signals_block();
497	#ifdef WITH_DB42
498	dbtxnp = bdb_cache_new_transaction(id, dn);
499	if (dbtxnp == NULL) {
500	signals_unblock();
501	return 1;
502	}
503	#else
504	dbtxnp = NULL;
505	#endif
506
507	if ((rv=dbp->del(dbp, dbtxnp, &key, 0)) != 0 && rv != DB_NOTFOUND) {
508	signals_unblock();
509	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
510	"removing from database failed: %s", dn);
511	dbp->err(dbp, rv, "del");
512	}
513
514	#ifdef WITH_DB42
515	dbtxnp->commit(dbtxnp, 0);
516	#endif
517	bdb_cache_sync();
518	signals_unblock();
519
520	return rv;
521	}
522
523	int bdb_cache_delete_entry_lower_upper(NotifierID id, char *dn)
524	{
525	char *lower_dn;
526	bool mixedcase = false;
527	int rv, rv2;
528
529	// convert to a lowercase dn
530	lower_dn = lower_utf8(dn);
531	rv=bdb_cache_delete_entry(id, lower_dn);
532	if (strcmp(dn, lower_dn) != 0) {
533	mixedcase = true;
534	// try again with original dn
535	rv2=bdb_cache_delete_entry(id, dn);
536	}
537
538	free(lower_dn);
539	if ( mixedcase ) {
540	return rv?rv2:rv; // if rv was bad (!=0) return rv2, otherwise return rv
541	} else {
542	return rv;
543	}
544	}
545
546	int bdb_cache_update_or_deleteifunused_entry(NotifierID id, char dn, CacheEntry entry)
547	{
548	if (entry->module_count == 0)
549	return bdb_cache_delete_entry(id, dn);
550	else
551	return bdb_cache_update_entry(id, dn, entry);
552	}
553
554	int bdb_cache_get_entry(char dn, CacheEntry entry)
555	{
556	DBT key, data;
557	int rv = 0;
558
559	memset(&key, 0, sizeof(DBT));
560	memset(&data, 0, sizeof(DBT));
561	memset(entry, 0, sizeof(CacheEntry));
562
563	key.data=dn;
564	key.size=strlen(dn)+1;
565	data.flags = DB_DBT_REALLOC;
566
567	signals_block();
568	rv=dbp->get(dbp, NULL, &key, &data, 0);
569	signals_unblock();
570
571	if (rv != 0 && rv != DB_NOTFOUND) {
572	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
573	"reading %s from database failed", dn);
574	dbp->err(dbp, rv, "get");
575	return rv;
576	} else if (rv == DB_NOTFOUND) {
577	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "no cache entry found for %s",
578	dn);
579	return rv;
580	}
581
582	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "got %d bytes for %s",
583	data.size, dn);
584
585	if ((rv=parse_entry(data.data, data.size, entry)) != 0) {
586	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
587	"parsing entry failed");
588	free(data.data);
589	exit(1);
590	}
591
592	free(data.data);
593	return rv;
594	}
595
596	int bdb_cache_get_entry_lower_upper(char dn, CacheEntry entry)
597	{
598	char *lower_dn;
599	bool mixedcase = false;
600	int rv;
601
602	// convert to a lowercase dn
603	lower_dn = lower_utf8(dn);
604	if (strcmp(dn, lower_dn) != 0) {
605	mixedcase = true;
606	}
607
608	rv = bdb_cache_get_entry(lower_dn, entry);
609	if (rv == DB_NOTFOUND && mixedcase ) {
610	// try again with original dn
611	rv = bdb_cache_get_entry(dn, entry);
612	}
613
614	free(lower_dn);
615	return rv;
616	}
617
618	int bdb_cache_first_entry(DBC cur, char dn, CacheEntry *entry)
619	{
620	int rv;
621
622	if ((rv=dbp->cursor(dbp, NULL, cur, 0)) != 0) {
623	dbp->err(dbp, rv, "cursor");
624	return rv;
625	}
626
627	return bdb_cache_next_entry(cur, dn, entry);
628	}
629
630	int bdb_cache_print_entries(char *dn)
631	{
632	DBT key, data;
633	DBC *cur;
634	memset(&key, 0, sizeof(DBT));
635	memset(&data, 0, sizeof(DBT));
636	key.data = strdup(dn);
637	key.size = strlen(dn)+1;
638	key.flags = DB_DBT_REALLOC;
639	data.flags = DB_DBT_REALLOC;
640
641	dbp->cursor(dbp, NULL, &cur, 0);
642	cur->c_get(cur, &key, &data, DB_FIRST);
643	do {
644	printf("%s\n", (char*)key.data);
645	} while (cur->c_get(cur, &key, &data, DB_NEXT) == 0);
646
647	cur->c_close(cur);
648	free(key.data);
649	free(data.data);
650	return 0;
651	}
652
653	int bdb_cache_next_entry(DBC cur, char dn, CacheEntry *entry)
654	{
655	DBT key, data;
656	int rv;
657
658	memset(&key, 0, sizeof(DBT));
659	key.flags = DB_DBT_REALLOC;
660	memset(&data, 0, sizeof(DBT));
661	data.flags = DB_DBT_REALLOC;
662
663	if ((rv=(cur)->c_get(cur, &key, &data, DB_NEXT)) == DB_NOTFOUND) {
664	return rv;
665	} else if (rv != 0) {
666	dbp->err(dbp, rv, "c_get");
667	return rv;
668	}
669
670	/* skip master entry */
671	if (strcmp(key.data, MASTER_KEY) == 0) {
672	free(key.data);
673	free(data.data);
674	return bdb_cache_next_entry(cur, dn, entry);
675	}
676
677	if (*dn)
678	free(*dn);
679	*dn = strdup(key.data);
680
681	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "got %d bytes", data.size);
682
683	if ((rv=parse_entry(data.data, data.size, entry)) != 0) {
684	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
685	"parsing entry failed: %s", *dn);
686	printf("%d\n", data.size);
687	free(key.data);
688	free(data.data);
689	return rv;
690	}
691
692	free(key.data);
693	free(data.data);
694
695	return 0;
696	}
697
698	int bdb_cache_free_cursor(DBC *cur)
699	{
700	return cur->c_close(cur);
701	}
702
703	int bdb_cache_close(void)
704	{
705	int rv = 0;
706
707	if (dbp && (rv = dbp->close(dbp, 0)) != 0) {
708	dbp->err(dbp, rv, "close");
709	}
710	dbp = NULL;
711	#ifdef WITH_DB42
712	if ((rv = dbenvp->close(dbenvp, 0)) != 0) {
713	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
714	"closing database environment failed");
715	}
716	#endif
717	if (lock_fp != NULL) {
718	fclose(lock_fp);
719	lock_fp = NULL;
720	}
721	return rv;
722	}

Line 0 Link Here

(-)a/management/univention-directory-listener/src/cache_bdb.h (+94 lines)
		1	/*
		2	* Univention Directory Listener
		3	* header information for cache.c
		4	*
		5	* Copyright 2004-2017 Univention GmbH
		6	*
		7	* http://www.univention.de/
		8	*
		9	* All rights reserved.
		10	*
		11	* The source code of this program is made available
		12	* under the terms of the GNU Affero General Public License version 3
		13	* (GNU AGPL V3) as published by the Free Software Foundation.
		14	*
		15	* Binary versions of this program provided by Univention to you as
		16	* well as other copyrighted, protected or trademarked materials like
		17	* Logos, graphics, fonts, specific documentations and configurations,
		18	* cryptographic keys etc. are subject to a license agreement between
		19	* you and Univention and not subject to the GNU AGPL V3.
		20	*
		21	* In the case you use this program under the terms of the GNU AGPL V3,
		22	* the program is provided in the hope that it will be useful,
		23	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		24	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		25	* GNU Affero General Public License for more details.
		26	*
		27	* You should have received a copy of the GNU Affero General Public
		28	* License with the Debian GNU/Linux or Univention distribution in file
		29	* /usr/share/common-licenses/AGPL-3; if not, see
		30	* <http://www.gnu.org/licenses/>.
		31	*/
		32
		33	#ifndef _CACHE_BDB_H_
		34	#define _CACHE_BDB_H_
		35
		36	#include <db.h>
		37
		38	#include "network.h"
		39	#include "cache_entry.h"
		40
		41	extern char *bdb_cache_dir;
		42	extern char *bdb_ldap_dir;
		43
		44	typedef struct _BdbCacheMasterEntry {
		45	NotifierID id;
		46	NotifierID schema_id;
		47	} BdbCacheMasterEntry;
		48	extern BdbCacheMasterEntry bdb_cache_master_entry;
		49
		50	int bdb_cache_lock(void);
		51	int bdb_cache_init (void);
		52	void bdb_cache_sync(void);
		53	int bdb_cache_get_master_entry (BdbCacheMasterEntry *master_entry);
		54	int bdb_cache_update_master_entry (BdbCacheMasterEntry *master_entry,
		55	DB_TXN *dptxnp);
		56	int bdb_cache_update_entry (NotifierID id,
		57	char *dn,
		58	CacheEntry *entry);
		59	inline int bdb_cache_update_entry_lower (NotifierID id,
		60	char *dn,
		61	CacheEntry *entry);
		62	int bdb_cache_delete_entry (NotifierID id,
		63	char *dn);
		64	int bdb_cache_delete_entry_lower_upper (NotifierID id,
65	char *dn);
66	int bdb_cache_update_or_deleteifunused_entry (NotifierID id,
67	char *dn,
68	CacheEntry *entry);
69	int bdb_cache_get_entry(
70	char *dn,
71	CacheEntry *entry);
72	int bdb_cache_get_entry_lower_upper(
73	char *dn,
74	CacheEntry *entry);
75	int bdb_cache_first_entry (DBC **cur,
76	char **dn,
77	CacheEntry *entry);
78	int bdb_cache_next_entry (DBC **cur,
79	char **dn,
80	CacheEntry *entry);
81	int bdb_cache_free_cursor (DBC *cur);
82	int bdb_cache_close (void);
83
84	/* deprecated with DB42*/
85	int bdb_cache_set_int (char *key,
86	const NotifierID value);
87	int bdb_cache_get_int (char *key,
88	NotifierID *value,
89	const long def);
90
91	int bdb_cache_get_schema_id(NotifierID *value, const long def);
92	int bdb_cache_set_schema_id(const NotifierID value);
93
94	#endif /* _CACHE_BDB_H_ */

Line 0 Link Here

(-)a/management/univention-directory-listener/src/cache_dn.c (+566 lines)
		1	/*
		2	* example implementation for mdb dntree adjecency list
		3	*
		4	* Copyright 2016 Univention GmbH
		5	* Copyright 2016 Arvid Requate
		6	*
		7	* http://www.univention.de/
		8	*
		9	* All rights reserved.
		10	*
		11	* The source code of this program is made available
		12	* under the terms of the GNU Affero General Public License version 3
		13	* (GNU AGPL V3) as published by the Free Software Foundation.
		14	*
		15	* Binary versions of this program provided by Univention to you as
		16	* well as other copyrighted, protected or trademarked materials like
		17	* Logos, graphics, fonts, specific documentations and configurations,
		18	* cryptographic keys etc. are subject to a license agreement between
		19	* you and Univention and not subject to the GNU AGPL V3.
		20	*
		21	* In the case you use this program under the terms of the GNU AGPL V3,
		22	* the program is provided in the hope that it will be useful,
		23	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		24	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		25	* GNU Affero General Public License for more details.
		26	*
		27	* You should have received a copy of the GNU Affero General Public
		28	* License with the Debian GNU/Linux or Univention distribution in file
		29	* /usr/share/common-licenses/AGPL-3; if not, see
		30	* <http://www.gnu.org/licenses/>.
		31	*/
		32
		33	/*
		34	* Derived From: This code is derived from dn2id.c written by Howard Chu.
		35	* The code of dn2id.c has been published under OpenLDAP Public License.
		36	*
		37	* A copy of this license is available in the file LICENSE in the
		38	* top-level directory of the distribution or, alternatively, at
		39	* <http://www.OpenLDAP.org/license.html>.
		40	*/
		41
		42	#include <stdio.h>
		43	#include <unistd.h>
		44	#include <malloc.h>
		45	#include <stdlib.h>
		46	#include <sys/types.h>
		47	#include <sys/stat.h>
		48	#include <unistd.h>
		49	#include <assert.h>
		50	#include "cache_dn.h"
		51	#include <univention/debug.h>
		52
		53	int mdb_dupsort(const MDB_val a, const MDB_val b)
		54	{
		55	int diff;
		56	subDN sdn_a, sdn_b;
		57
		58	sdn_a = (subDN *)a->mv_data;
		59	sdn_b = (subDN *)b->mv_data;
		60
		61	diff = sdn_a->type - sdn_b->type;
		62	if (diff) {
		63	return diff;
		64	}
65	if (sdn_a->type == SUBDN_TYPE_LINK) {
66	return strcmp(sdn_a->data, sdn_b->data);
67	} else {
68	return 0;
69	}
70	}
71
72	unsigned int num_rdns(LDAPDN dn) {
73	unsigned int iRDN;
74
75	for (iRDN=0; dn[iRDN]; iRDN++);
76
77	return iRDN;
78	}
79
80	/* climb the dntree */
81	static int dntree_lookup_id4ldapdn(MDB_cursor cur, LDAPDN dn, DNID dnid_out, int *found_out)
82	{
83	int rv, iRDN, found;
84	MDB_val key, data;
85	DNID parent, id = 0;
86	char *rdn;
87	subDN *subdn;
88
89	key.mv_size = sizeof(DNID);
90
91	found = 0;
92	iRDN = num_rdns(dn);
93	for (iRDN--; iRDN>=0; iRDN--) {
94	rv = ldap_rdn2str(dn[iRDN], &rdn, LDAP_DN_FORMAT_LDAPV3);
95	if (rv != LDAP_SUCCESS) {
96	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
97	"%s: ldap_rdn2str failed: %s (%d)",
98	__func__, ldap_err2string(rv), rv);
99	return rv;
100	}
101
102	key.mv_data = &parent;
103	parent = id;
104
105	data.mv_size = sizeof(subDN) + strlen(rdn);
106	subdn = malloc(data.mv_size);
107	if (subdn == NULL) {
108	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
109	"%s: Malloc failed", __func__);
110	ldap_memfree(rdn);
111	abort();
112	}
113	subdn->type = SUBDN_TYPE_LINK;
114	strcpy(subdn->data, rdn);
115	ldap_memfree(rdn);
116	data.mv_data = subdn;
117
118	rv = mdb_cursor_get(cur, &key, &data, MDB_GET_BOTH);
119	free(subdn);
120
121	if (rv == MDB_NOTFOUND) {
122	break;
123	}
124	if (rv != MDB_SUCCESS) {
125	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
126	"%s: mdb_cursor_get failed: %s (%d)",
127	__func__, ldap_err2string(rv), rv);
128	return rv;
129	};
130
131	subdn = (subDN *) data.mv_data;
132	id = subdn->id;
133	found++;
134	}
135
136	if (rv == MDB_SUCCESS) {
137	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_INFO,
138	"%s: found id=%lu",
139	__func__, id);
140	} else if (rv != MDB_NOTFOUND) {
141	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
142	"%s: failed: %s (%d)",
143	__func__, mdb_strerror(rv), rv);
144	}
145
146	*dnid_out = id;
147	if (found_out) {
148	*found_out = found;
149	};
150
151	return rv;
152	}
153
154	int dntree_lookup_dn4id(MDB_cursor cur, DNID dnid, char *dn)
155	{
156	int rv;
157	MDB_val key, data;
158	subDN *subdn;
159	DNID id = dnid;
160
161	key.mv_size = sizeof(DNID);
162	key.mv_data = &id;
163
164	data.mv_size = sizeof(subDN);
165	subdn = malloc(data.mv_size);
166	if (subdn == NULL) {
167	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
168	"%s: Malloc failed", __func__);
169	abort();
170	}
171	subdn->type = SUBDN_TYPE_NODE;
172	data.mv_data = subdn;
173
174	rv = mdb_cursor_get(cur, &key, &data, MDB_GET_BOTH);
175	free(subdn);
176	data.mv_data = NULL;
177	data.mv_size = 0;
178
179	if (rv != MDB_SUCCESS) {
180	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
181	"%s: mdb_cursor_get (MDB_GET_BOTH): %s (%d)",
182	__func__, mdb_strerror(rv), rv);
183	return rv;
184	};
185
186	// Workaround for (ITS#8393) LMDB - MDB_GET_BOTH broken on non-dup value
187	rv = mdb_cursor_get(cur, &key, &data, MDB_GET_CURRENT);
188	if (rv != MDB_SUCCESS) {
189	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
190	"%s: mdb_cursor_get: %s (%d)",
191	__func__, mdb_strerror(rv), rv);
192	return rv;
193	};
194
195	/*
196	* or simply use this instead of MDB_GET_BOTH + MDB_GET_CURRENT:
197	MDB_txn *txn;
198	MDB_dbi dbi;
199	txn = mdb_cursor_txn(cur);
200	dbi = mdb_cursor_dbi(cur);
201	rv = mdb_get(txn, dbi, &key, &data);
202	if (rv != MDB_SUCCESS) {
203	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
204	"%s: mdb_get: %s (%d)",
205	__func__, mdb_strerror(rv), rv);
206	return rv;
207	};
208	*/
209
210	subdn = (subDN *) data.mv_data;
211
212	*dn = malloc(strlen(subdn->data) + 1);
213	if (*dn == NULL) {
214	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
215	"%s: Malloc failed", __func__);
216	abort();
217	}
218	strcpy(*dn, subdn->data);
219
220	return rv;
221	}
222
223	static int next_free_dnid(MDB_cursor cur, DNID dnid_out)
224	{
225	int rv;
226	MDB_val key;
227
228	rv = mdb_cursor_get(cur, &key, NULL, MDB_LAST);
229	if (rv == MDB_SUCCESS) {
230	dnid_out = ((DNID *) key.mv_data) + 1;
231	return rv;
232	} else if (rv == MDB_NOTFOUND) {
233	*dnid_out = 1;
234	return MDB_SUCCESS;
235	} else {
236	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
237	"%s: mdb_cursor_get: %s (%d)",
238	__func__, mdb_strerror(rv), rv);
239	return rv;
240	}
241	}
242
243	static int dntree_add_id(MDB_cursor *write_cursor_p, DNID child, LDAPDN dn, DNID parent)
244	{
245	int rv;
246	MDB_val key, data;
247	DNID id;
248	char *rdn_str;
249	char *dn_str;
250	size_t dn_len;
251	size_t rdn_len;
252	subDN *subdn;
253
254	key.mv_size = sizeof(DNID);
255	key.mv_data = &id;
256	id = parent;
257
258	rv = ldap_dn2str(dn, &dn_str, LDAP_DN_FORMAT_LDAPV3);
259	if (rv != LDAP_SUCCESS) {
260	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
261	"%s: ldap_dn2str failed: %s (%d)",
262	__func__, ldap_err2string(rv), rv);
263	return rv;
264	}
265
266	rv = ldap_rdn2str(dn[0], &rdn_str, LDAP_DN_FORMAT_LDAPV3);
267	if (rv != LDAP_SUCCESS) {
268	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
269	"%s: ldap_rdn2str failed: %s (%d)",
270	__func__, ldap_err2string(rv), rv);
271	ldap_memfree(dn_str);
272	return rv;
273	}
274
275	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_INFO,
276	"%s: child=%lu, parent=%lu: \"%s\"",
277	__func__, child, parent, rdn_str);
278
279	dn_len = strlen(dn_str);
280	subdn = malloc(sizeof(subDN) + dn_len);
281	rdn_len = strlen(rdn_str);
282	assert(dn_len >= rdn_len);
283	data.mv_size = sizeof(subDN) + rdn_len;
284	if (subdn == NULL) {
285	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
286	"%s: Malloc failed", __func__);
287	ldap_memfree(dn_str);
288	ldap_memfree(rdn_str);
289	abort();
290	}
291	subdn->type = SUBDN_TYPE_LINK;
292	subdn->id = child;
293	strcpy(subdn->data, rdn_str);
294	ldap_memfree(rdn_str);
295	data.mv_data = subdn;
296
297	// Store subdn link
298	rv = mdb_cursor_put(write_cursor_p, &key, &data, MDB_NODUPDATA);
299
300	// Store subdn node
301	if (rv == MDB_SUCCESS) {
302	id = child;
303
304	data.mv_size = sizeof(subDN) + dn_len;
305	subdn->type = SUBDN_TYPE_NODE;
306	subdn->id = parent; // backlink
307	strcpy(subdn->data, dn_str);
308
309	rv = mdb_cursor_put(write_cursor_p, &key, &data, MDB_NODUPDATA);
310	if (rv != MDB_SUCCESS) {
311	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
312	"%s: mdb_cursor_put failed for child %lu: %s (%d)",
313	__func__, id, mdb_strerror(rv), rv);
314	}
315	} else {
316	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
317	"%s: mdb_cursor_put failed for parent %lu: %s (%d)",
318	__func__, id, mdb_strerror(rv), rv);
319	}
320	ldap_memfree(dn_str);
321	free(subdn);
322
323	return rv;
324	}
325
326	static int dntree_has_children(MDB_cursor *local_cursor, DNID dnid)
327	{
328	int rv;
329	size_t values;
330	MDB_val key, data;
331
332	key.mv_size = sizeof(DNID);
333	key.mv_data = &dnid;
334
335	rv = mdb_cursor_get(local_cursor, &key, &data, MDB_SET);
336	if (rv != MDB_SUCCESS) {
337	return rv;
338	}
339
340	rv = mdb_cursor_count(local_cursor, &values);
341	if (rv == MDB_SUCCESS && values < 2) {
342	rv = MDB_NOTFOUND;
343	}
344	return rv;
345	}
346
347	int dntree_del_id(MDB_cursor *write_cursor_p, DNID dnid)
348	{
349	int rv;
350	MDB_val key, data;
351	MDB_cursor *local_read_cursor_p;
352	MDB_txn *txn;
353	MDB_dbi dbi;
354
355	txn = mdb_cursor_txn(write_cursor_p);
356	dbi = mdb_cursor_dbi(write_cursor_p);
357	rv = mdb_cursor_open(txn, dbi, &local_read_cursor_p);
358	if (rv != MDB_SUCCESS) {
359	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
360	"%s: mdb_cursor_open: %s (%d)",
361	__func__, ldap_err2string(rv), rv);
362	return rv;
363	}
364
365	rv = dntree_has_children(local_read_cursor_p, dnid);
366	if (rv == MDB_SUCCESS) {
367	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
368	"%s: delete failed:"
369	" subordinate objects must be deleted first",
370	__func__);
371	return -1;
372	} else if (rv != MDB_NOTFOUND) {
373	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
374	"%s: dntree_has_children failed: %s (%d)",
375	__func__, mdb_strerror(rv), rv);
376	return -1;
377	}
378	mdb_cursor_close(local_read_cursor_p);
379
380	// dntree_lookup_id4ldapdn positioned cursor on SUBDN_TYPE_LINK node below parent's key
381	rv = mdb_cursor_del(write_cursor_p, 0);
382
383	if (rv == MDB_SUCCESS) {
384	key.mv_size = sizeof(DNID);
385	key.mv_data = &dnid;
386	rv = mdb_cursor_get(write_cursor_p, &key, &data, MDB_SET);
387	if (rv == MDB_SUCCESS) {
388	rv = mdb_cursor_del(write_cursor_p, 0);
389	}
390	}
391
392	return rv;
393	}
394
395	int dntree_del_ldapdn(MDB_cursor *write_cursor_p, LDAPDN dn)
396	{
397	int rv;
398	DNID id;
399
400	rv = dntree_lookup_id4ldapdn(write_cursor_p, dn, &id, NULL);
401	if (rv != MDB_SUCCESS) {
402	return rv;
403	}
404
405	return dntree_del_id(write_cursor_p, id);
406	}
407
408
409	static int dntree_get_id4ldapdn(MDB_cursor write_cursor_p, LDAPDN dn, DNID dnid_out)
410	{
411	int rv, found;
412	DNID id, parent = 0;
413	LDAPDN pdn;
414
415	if (dn == NULL) {
416	*dnid_out = 0;
417	return MDB_SUCCESS;
418	}
419
420	rv = dntree_lookup_id4ldapdn(write_cursor_p, dn, &id, &found);
421	if (rv == MDB_NOTFOUND) {
422	pdn = &dn[1];
423	if (num_rdns(pdn) != found) {
424	rv = dntree_get_id4ldapdn(write_cursor_p, pdn, &parent);
425	if (rv != MDB_SUCCESS) {
426	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
427	"%s: failed: %s (%d)",
428	__func__, mdb_strerror(rv), rv);
429	return rv;
430	}
431	} else {
432	parent = id;
433	}
434	rv = next_free_dnid(write_cursor_p, &id);
435	if (rv != MDB_SUCCESS) {
436	return rv;
437	}
438	rv = dntree_add_id(write_cursor_p, id, dn, parent);
439	}
440
441	*dnid_out = id;
442
443	return rv;
444	}
445
446	int dntree_get_id4dn(MDB_cursor id2dn_cursor_p, char dn, DNID *dnid, bool create)
447	{
448	int rv;
449	LDAPDN ldapdn;
450
451	rv = ldap_str2dn(dn, &ldapdn, LDAP_DN_FORMAT_LDAP);
452	if (rv != LDAP_SUCCESS) {
453	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
454	"%s: ldap_str2dn failed: %s (%d)",
455	__func__, ldap_err2string(rv), rv);
456	return rv;
457	}
458
459	if (ldapdn == NULL) {
460	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
461	"%s: ldap_str2dn NULL: %s (%d): %s",
462	__func__, ldap_err2string(rv), rv, dn);
463	return 1;
464	}
465
466	if (create == true) {
467	rv = dntree_get_id4ldapdn(id2dn_cursor_p, ldapdn, dnid);
468	if (rv != MDB_SUCCESS) {
469	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
470	"%s: failed for: %s",
471	__func__, dn);
472	}
473
474	} else {
475	rv = dntree_lookup_id4ldapdn(id2dn_cursor_p, ldapdn, dnid, NULL);
476	if (rv == MDB_NOTFOUND) {
477	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_INFO,
478	"%s: DN %s not in id2dn",
479	__func__, dn);
480	}
481	}
482
483	ldap_dnfree(ldapdn);
484	return rv;
485	}
486
487	int dntree_del_dn(MDB_cursor write_cursor_p, char dn)
488	{
489	int rv;
490	LDAPDN ldapdn;
491
492	rv = ldap_str2dn(dn, &ldapdn, LDAP_DN_FORMAT_LDAP);
493	if (rv != LDAP_SUCCESS) {
494	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
495	"%s: ldap_str2dn failed: %s (%d)",
496	__func__, ldap_err2string(rv), rv);
497	return rv;
498	}
499
500	if (ldapdn == NULL) {
501	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
502	"%s: ldap_str2dn NULL: %s (%d): %s",
503	__func__, ldap_err2string(rv), rv, dn);
504	return 1;
505	}
506
507	rv = dntree_del_ldapdn(write_cursor_p, ldapdn);
508
509	ldap_dnfree(ldapdn);
510	return rv;
511	}
512
513
514	int dntree_init(MDB_dbi dbi_p, MDB_txn cache_init_txn_p, int mdb_flags)
515	{
516	int rv;
517	MDB_val key, data;
518	MDB_cursor *cur;
519	int mdb_dbi_flags = MDB_INTEGERKEY\|MDB_DUPSORT;
520	bool readonly = (mdb_flags & MDB_RDONLY) != 0;
521
522	if (!readonly) {
523	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_INFO,
524	"dntree_init: MDB_RDONLY");
525	mdb_dbi_flags \|= MDB_CREATE;
526	}
527
528	rv = mdb_dbi_open(cache_init_txn_p, "id2dn", mdb_dbi_flags, dbi_p);
529	if (rv != MDB_SUCCESS) {
530	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
531	"%s: mdb_dbi_open: %s (%d)",
532	__func__, mdb_strerror(rv), rv);
533	return rv;
534	};
535	rv = mdb_set_dupsort(cache_init_txn_p, *dbi_p, mdb_dupsort);
536	if (rv != MDB_SUCCESS) {
537	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
538	"%s: mdb_set_dupsort: %s (%d)",
539	__func__, mdb_strerror(rv), rv);
540	return rv;
541	};
542
543	if (readonly) {
544	return MDB_SUCCESS;
545	}
546
547	rv = mdb_cursor_open(cache_init_txn_p, *dbi_p, &cur);
548	if (rv != MDB_SUCCESS) {
549	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
550	"%s: mdb_cursor_open: %s (%d)",
551	__func__, mdb_strerror(rv), rv);
552	return rv;
553	};
554
555	// create root node
556	key.mv_size = sizeof(DNID);
557	key.mv_data = &(DNID) {0};
558	data.mv_size = sizeof(subDN);
559	data.mv_data = &(subDN) {0, SUBDN_TYPE_NODE, {0}};
560	// ignore exists
561	mdb_cursor_put(cur, &key, &data, MDB_NODUPDATA);
562	// not strictly required, mdb_txn_commit does it for write txn
563	mdb_cursor_close(cur);
564
565	return MDB_SUCCESS;
566	}

Line 0 Link Here

(-)a/management/univention-directory-listener/src/cache_dn.h (+64 lines)
	1	/*
	2	* header information for dntree.c
	3	*
	4	* Copyright 2016 Univention GmbH
	5	* Copyright 2016 Arvid Requate
	6	*
	7	* http://www.univention.de/
	8	*
	9	* All rights reserved.
	10	*
	11	* The source code of this program is made available
	12	* under the terms of the GNU Affero General Public License version 3
	13	* (GNU AGPL V3) as published by the Free Software Foundation.
	14	*
	15	* Binary versions of this program provided by Univention to you as
	16	* well as other copyrighted, protected or trademarked materials like
	17	* Logos, graphics, fonts, specific documentations and configurations,
	18	* cryptographic keys etc. are subject to a license agreement between
	19	* you and Univention and not subject to the GNU AGPL V3.
	20	*
	21	* In the case you use this program under the terms of the GNU AGPL V3,
	22	* the program is provided in the hope that it will be useful,
	23	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	24	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	25	* GNU Affero General Public License for more details.
	26	*
	27	* You should have received a copy of the GNU Affero General Public
	28	* License with the Debian GNU/Linux or Univention distribution in file
	29	* /usr/share/common-licenses/AGPL-3; if not, see
	30	* <http://www.gnu.org/licenses/>.
	31	*/
	32
	33	#ifndef _DNTREE_H_
	34	#define _DNTREE_H_
	35
	36	#include <stdbool.h>
	37	#include <lmdb.h>
	38	#include <ldap.h>
	39
	40	typedef struct mdb_ctx {
	41	MDB_env *env;
	42	MDB_dbi dbi;
	43	MDB_txn *txn;
	44	MDB_cursor *cur;
	45	} mdb_ctx;
	46
	47	#define SUBDN_TYPE_NODE 0
	48	#define SUBDN_TYPE_LINK 1
	49
	50	typedef unsigned char SUBDNTYPE;
	51	typedef unsigned long DNID;
	52	typedef struct subDN {
	53	DNID id;
	54	SUBDNTYPE type;
	55	char data[1];
	56	} subDN;
	57
	58	int dntree_init(MDB_dbi dbi_ptr, MDB_txn write_txn_p, int mdb_flags);
	59	int dntree_get_id4dn(MDB_cursor cursor, char dn, DNID *dnid, bool create);
	60	int dntree_lookup_dn4id(MDB_cursor cur, DNID dnid, char *dn);
	61	int dntree_del_id(MDB_cursor *cursor, DNID dnid);
	62	int dntree_del_ldapdn(MDB_cursor *cursor, LDAPDN dn);
	63
	64	#endif /* _DNTREE_H_ */

Line 0 Link Here

(-)a/management/univention-directory-listener/src/convert.c (+134 lines)
		1	/*
		2	* Univention Directory Listener
		3	* tool to convert the cache.
		4	*
		5	* Copyright 2016-2017 Univention GmbH
		6	*
		7	* http://www.univention.de/
		8	*
		9	* All rights reserved.
		10	*
		11	* The source code of this program is made available
		12	* under the terms of the GNU Affero General Public License version 3
		13	* (GNU AGPL V3) as published by the Free Software Foundation.
		14	*
		15	* Binary versions of this program provided by Univention to you as
		16	* well as other copyrighted, protected or trademarked materials like
		17	* Logos, graphics, fonts, specific documentations and configurations,
		18	* cryptographic keys etc. are subject to a license agreement between
		19	* you and Univention and not subject to the GNU AGPL V3.
		20	*
		21	* In the case you use this program under the terms of the GNU AGPL V3,
		22	* the program is provided in the hope that it will be useful,
		23	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		24	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		25	* GNU Affero General Public License for more details.
		26	*
		27	* You should have received a copy of the GNU Affero General Public
		28	* License with the Debian GNU/Linux or Univention distribution in file
		29	* /usr/share/common-licenses/AGPL-3; if not, see
		30	* <http://www.gnu.org/licenses/>.
		31	*/
		32
		33	#include <stdio.h>
		34	#include <unistd.h>
		35	#include <string.h>
		36	#include <stdlib.h>
		37	#include <fcntl.h>
		38	#include <dirent.h>
		39	#include <pwd.h>
		40	#include <sys/types.h>
		41
		42	#include <univention/debug.h>
		43
		44	#include "cache_bdb.h"
		45	#include "cache.h"
		46	#include "common.h"
		47
		48
		49	static void usage(void)
		50	{
		51	fprintf(stderr, "Usage: univention-directory-listener-convert [options]\n");
		52	fprintf(stderr, "Options:\n");
		53	fprintf(stderr, " -d debugging\n");
		54	fprintf(stderr, " -c Listener cache path\n");
		55	}
		56
		57
		58	int main(int argc, char* argv[])
		59	{
		60	int debugging = 0;
		61	int rv;
		62	DBC *cur;
		63	char *dn = NULL;
		64	CacheEntry entry;
65
66	univention_debug_init("stderr", 1, 1);
67
68	/* parse arguments */
69	for (;;) {
70	int c;
71
72	c = getopt(argc, argv, "d:c:");
73	if (c < 0)
74	break;
75	switch (c) {
76	case 'd':
77	debugging=atoi(optarg);
78	break;
79	case 'c':
80	cache_dir=strdup(optarg);
81	bdb_cache_dir=strdup(optarg);
82	break;
83	default:
84	usage();
85	exit(1);
86	}
87	}
88
89	if (debugging > 1) {
90	univention_debug_set_level(UV_DEBUG_LISTENER, UV_DEBUG_ALL);
91	univention_debug_set_level(UV_DEBUG_LDAP, UV_DEBUG_ALL);
92	univention_debug_set_level(UV_DEBUG_KERBEROS, UV_DEBUG_ALL);
93	} else if ( debugging > 0 ) {
94	univention_debug_set_level(UV_DEBUG_LISTENER, UV_DEBUG_INFO);
95	univention_debug_set_level(UV_DEBUG_LDAP, UV_DEBUG_INFO);
96	univention_debug_set_level(UV_DEBUG_KERBEROS, UV_DEBUG_INFO);
97	} else {
98	univention_debug_set_level(UV_DEBUG_LISTENER, UV_DEBUG_ERROR);
99	univention_debug_set_level(UV_DEBUG_LDAP, UV_DEBUG_ERROR);
100	univention_debug_set_level(UV_DEBUG_KERBEROS, UV_DEBUG_ERROR);
101	}
102
103	rv = bdb_cache_lock();
104	rv = cache_lock();
105
106	if (bdb_cache_init() != 0)
107	exit(1);
108
109	if (cache_init(0) != 0)
110	exit(1);
111
112	bdb_cache_get_master_entry(&bdb_cache_master_entry);
113	rv = cache_update_master_entry(&cache_master_entry, NULL);
114
115	for (rv=bdb_cache_first_entry(&cur, &dn, &entry); rv != DB_NOTFOUND;
116	rv=bdb_cache_next_entry(&cur, &dn, &entry)) {
117	if (rv != 0) {
118	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
119	"error while reading database");
120	} else if ((rv=cache_update_entry_lower(0, dn, &entry)) != MDB_SUCCESS) {
121	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
122	"error while writing to database");
123	}
124	cache_free_entry(&dn, &entry);
125	if (rv < -1) break;
126	}
127
128	bdb_cache_free_cursor(cur);
129
130	bdb_cache_close();
131	cache_close();
132
133	return 0;
134	}