Attachment #7910 for bug #23367

Lines 7-13 Link Here

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

Lines 37-43 Link Here

(-)debian/rules (-1 / +1 lines)
37		37
38	override_dh_auto_build:	38	override_dh_auto_build:
39	$(MAKE) -C src clean	39	$(MAKE) -C src clean
40	$(MAKE) -C src DB_CFLAGS="-I/usr/include/db3 -DWITH_DB3" DB_LDADD="-ldb3"	40	$(MAKE) -C src DB_LDADD="-llmdb"
41	dh_auto_build	41	dh_auto_build
42		42
43	override_dh_auto_install:	43	override_dh_auto_install:

Lines 45-50 Link Here

(-)debian/univention-directory-listener.postinst (+8 lines)
45	chown listener /var/lib/univention-ldap/listener/listener*	45	chown listener /var/lib/univention-ldap/listener/listener*
46	fi	46	fi
47		47
		48	if [ ! -e /var/lib/univention-directory-listener/cache ]; then
		49	mkdir /var/lib/univention-directory-listener/cache
		50	if [ -f /var/lib/univention-directory-listener/cache.db ]; then
		51	db_dump /var/lib/univention-directory-listener/cache.db \| \
		52	mdb_load /var/lib/univention-directory-listener/cache
		53	fi
		54	fi
		55
48	#DEBHELPER#	56	#DEBHELPER#
49		57
50	univention-config-registry set listener/debug/level?2 \	58	univention-config-registry set listener/debug/level?2 \

Lines 30-40 Link Here

(-)src/Makefile (-4 / +3 lines)
30	# <http://www.gnu.org/licenses/>.	30	# <http://www.gnu.org/licenses/>.
31	#	31	#
32	CC=gcc	32	CC=gcc
33	DB_LDADD=-ldb3	33	DB_LDADD=-llmdb
34	DB_CFLAGS=-I/usr/include/db3 -DWITH_DB3
35	DB_OBJS=cache.o cache_entry.o cache_lowlevel.o base64.o filter.o	34	DB_OBJS=cache.o cache_entry.o cache_lowlevel.o base64.o filter.o
36		35
37	CFLAGS=-g -Wall -Werror -D_FILE_OFFSET_BITS=64 $(DB_CFLAGS)	36	CFLAGS=-g -Wall -Werror -D_FILE_OFFSET_BITS=64
38	LDADD=-g -luniventiondebug -licuuc	37	LDADD=-g -luniventiondebug -licuuc
39	LISTENER_LDADD=$(LDADD) -luniventionpolicy -lldap -lpython2.7 $(DB_LDADD)	38	LISTENER_LDADD=$(LDADD) -luniventionpolicy -lldap -lpython2.7 $(DB_LDADD)
40	LISTENER_OBJS=main.o notifier.o transfile.o handlers.o change.o network.o signals.o select_server.o utils.o $(DB_OBJS)	39	LISTENER_OBJS=main.o notifier.o transfile.o handlers.o change.o network.o signals.o select_server.o utils.o $(DB_OBJS)
Lines 62-65 Link Here
62		61
63	.PHONY: clean	62	.PHONY: clean
64	clean:	63	clean:
65	$(RM) .o listener dump demo verify .db3 *.db42	64	$(RM) *.o listener dump demo verify




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



CacheMasterEntry cache_master_entry;

MDB_env *env;
MDB_dbi dbi;
DB_ENV *dbenvp;
#endif
static FILE *lock_fp=NULL;

static struct filter cache_filter;

	}
}

static void cache_error_message(int rv, char *msg)
static void cache_panic_call(DB_ENV *dbenvp, int errval)
{
	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
			"database error: %s: %s (%d)\n",
			msg, mdb_strerror(rv), rv);
}
#endif

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

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();


int cache_init(void)
{
	int rv;
	char mdb_dir[PATH_MAX];
	MDB_txn *txn;

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

	if ((rv = mdb_env_create(&env)) != 0) {
	if ((rv = db_env_create(&dbenvp, 0)) != 0) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"creating environment handle failed");
		cache_error_message(rv, "mdb_env_create");
		return rv;
	}
	if ((rv = mdb_env_set_mapsize(env, 1992294400)) != 0) {
	dbenvp->set_paniccall(dbenvp, cache_panic_call);
	if ((rv = dbenvp->open(dbenvp, 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,
				"setting mdb mapsize failed");
		cache_error_message(rv, "mdb_env_set_mapsize");
		return rv;
	}
	if ((rv = mdb_env_open(env, mdb_dir, MDB_NORDAHEAD, 0600)) != 0) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"opening database failed");
		cache_error_message(rv, "mdb_env_open");
		return rv;
	}
	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "Transaction begin (cache_init)");
	if ((rv = mdb_txn_begin(env, NULL, 0, &txn)) != 0) {
		cache_error_message(rv, "mdb_txn_begin");
		mdb_env_close(env);
				"opening database failed");
		dbp->err(dbp, rv, "open");
		// FIXME: free dbp
		return rv;
	}
	if ((rv = mdb_open(txn, NULL, 0, &dbi)) != 0) {
		cache_error_message(rv, "mdb_open");
		mdb_txn_abort(txn);
		mdb_env_close(env);
		return rv;
	}
	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "Transaction commit (cache_init)");
	if ((rv = mdb_txn_commit(txn)) != 0) {
		cache_error_message(rv, "mdb_txn_commit");
		mdb_dbi_close(env, dbi);
		mdb_env_close(env);
		return rv;
	}

#endif
	setup_cache_filter();
	return 0;
}

void cache_sync(void) {
	if (!INIT_ONLY && dbp) {
		dbp->sync(dbp, 0);
	}
}

int cache_set_schema_id(const NotifierID value)
{
	int rv, fd, len;


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

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

	key.mv_data=MASTER_KEY;
	key.mv_size=MASTER_KEY_SIZE;
	data.flags = DB_DBT_REALLOC;

	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "Transaction begin (cache_get_master_entry)");
	if ((rv = mdb_txn_begin(env, NULL, MDB_RDONLY, &txn)) != 0) {
		cache_error_message(rv, "mdb_txn_begin");
		return rv;
	}
	if ((rv = mdb_get(txn, dbi, &key, &data)) == MDB_NOTFOUND) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "Transaction abort (cache_get_master_entry)");
		mdb_txn_abort(txn);
		return rv;
	}
	else if (rv != 0) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"reading master entry from database failed");
		cache_error_message(rv, "mdb_get");
		mdb_txn_abort(txn);
		return rv;
	}
	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "Transaction abort (cache_get_master_entry)");
	mdb_txn_abort(txn);

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

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

	return 0;
}

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

	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 = 0;
	if (dbtxnp == NULL)
		flags = DB_AUTO_COMMIT;
	else
#endif
		flags = 0;

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

	cache_sync();

	return 0;
}

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

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

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


			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(txn);
			return NULL;
		} else
			*old_id = id;

		if (cache_update_master_entry(&master_entry, txn) != 0) {
			mdb_txn_abort(txn);
			return NULL;
		}
	}

	return txn;
#else
	return NULL;
#endif

   cache_delete_entry do nothing (at least if WITH_DB42 is undefined) */
inline int cache_update_entry(NotifierID id, char *dn, CacheEntry *entry)
{
	MDB_txn *txn;
	MDB_val key, data;
	int rv = 0;

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

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


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

	key.mv_data=dn;
	key.mv_size=strlen(dn)+1;

	if ((rv = mdb_put(txn, dbi, &key, &data, 0)) != 0) {
		signals_unblock();
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"storing entry in database failed: %s", dn);
		cache_error_message(rv, "mdb_put");
		mdb_txn_abort(txn);
		dbtxnp->abort(dbtxnp);
#endif
		free(data.data);
		return rv;
	}
	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "put %zu bytes for %s", data.mv_size, dn);


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

	signals_unblock();

	free(data.data);
	return rv;
}



int cache_delete_entry(NotifierID id, char *dn)
{
	MDB_txn *txn;
	MDB_val	 key;
	int	 rv;

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

	key.mv_data=dn;
	key.mv_size=strlen(dn)+1;

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

	if ((rv = mdb_del(txn, dbi, &key, 0)) != 0 && rv != MDB_NOTFOUND) {
		signals_unblock();
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"removing from database failed: %s", dn);
		cache_error_message(rv, "mdb_del");
		mdb_txn_abort(txn);
		return rv;
	}

	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "Transaction commit (cache_delete_entry)");
	if ((rv = mdb_txn_commit(txn)) != 0) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"storing entry removal from database failed");
		cache_error_message(rv, "mdb_txn_commit");
		return rv;
	}
	signals_unblock();

	return rv;


int cache_get_entry(char *dn, CacheEntry *entry)
{
	MDB_txn *txn;
	MDB_val key, data;
	int rv = 0;

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

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

	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "Transaction begin (cache_get_entry)");
	if ((rv = mdb_txn_begin(env, NULL, MDB_RDONLY, &txn)) != 0) {
		cache_error_message(rv, "mdb_txn_begin");
		return rv;
	}
	signals_block();
	rv = mdb_get(txn, dbi, &key, &data);
	signals_unblock();
	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "Transaction abort (cache_get_entry)");
	mdb_txn_abort(txn);

	if (rv != 0 && rv != MDB_NOTFOUND) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"reading %s from database failed", dn);
		cache_error_message(rv, "mdb_get");
		return rv;
	} else if (rv == MDB_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 %zu bytes for %s",
			data.mv_size, dn);

	if ((rv=parse_entry(data.mv_data, data.mv_size, entry)) != 0) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR,
				"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 **cursor, char **dn, CacheEntry *entry)
{
	MDB_txn *txn;
	int rv;

	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "Transaction begin (cache_first_entry)");
	if ((rv = mdb_txn_begin(env, NULL, MDB_RDONLY, &txn)) != 0) {
		cache_error_message(rv, "mdb_txn_begin");
		return rv;
	}
	if ((rv = mdb_cursor_open(txn, dbi, cursor)) != 0) {
		cache_error_message(rv, "mdb_cursor_open");
		mdb_txn_abort(txn);
		return rv;
	}

	/*
	// mdb_reader_list(env, &mdb_message_func, NULL);
	MDB_envinfo stat;
	MDB_env *env = mdb_txn_env(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(cursor, dn, entry);
}

int cache_print_entries(char *dn)
{
	MDB_txn *txn;
	MDB_val key, data;
	MDB_cursor *cursor;
	int rv = 0;
	key.data = strdup(dn);
	key.size = strlen(dn)+1;
	key.flags = DB_DBT_REALLOC;
	data.flags = DB_DBT_REALLOC;

	memset(&key, 0, sizeof(MDB_val));
	memset(&data, 0, sizeof(MDB_val));
	key.mv_data = strdup(dn);
	key.mv_size = strlen(dn)+1;

	if ((rv = mdb_txn_begin(env, NULL, MDB_RDONLY, &txn)) != 0) {
		cache_error_message(rv, "mdb_txn_begin");
		return rv;
	}
	if ((rv = mdb_cursor_open(txn, dbi, &cursor)) != 0) {
		cache_error_message(rv, "mdb_cursor_open");
		mdb_txn_abort(txn);
		return rv;
	}
	rv = mdb_cursor_get(cursor, &key, &data, MDB_FIRST);
	do {
		if (rv != 0) {
			cache_error_message(rv, "mdb_cursor_get");
			mdb_txn_abort(txn);
			return rv;
		}
		printf("%s\n", (char*)key.mv_data);
	} while ((rv = mdb_cursor_get(cursor, &key, &data, MDB_NEXT)));

	mdb_cursor_close(cursor);
	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "Transaction abort (cache_print_entries)");
	mdb_txn_abort(txn);
	return 0;
}

int cache_next_entry(MDB_cursor **cursor, char **dn, CacheEntry *entry)
{
	MDB_val key, data;
	int rv;

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

	if ((rv=mdb_cursor_get(*cursor, &key, &data, MDB_NEXT)) == MDB_NOTFOUND) {
		return rv;
	} else if (rv != 0) {
		cache_error_message(rv, "mdb_cursor_get");
		return rv;
	}

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

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

	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "got %zu bytes", data.mv_size);

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

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

	return 0;
}

int cache_free_cursor(MDB_cursor *cursor)
{
	int rv;
	MDB_txn *txn;

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

	txn = mdb_cursor_txn(cursor);
	mdb_cursor_close(cursor);

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

void cache_close(void)
{
	mdb_close(env, dbi);
	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"

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);

int	cache_get_entry_lower_upper(
						 char			 *dn,
						 CacheEntry		 *entry);
int	cache_first_entry			(MDB_cursor		**cur,
						 char			**dn,
						 CacheEntry		 *entry);
int	cache_next_entry			(MDB_cursor		**cur,
						 char			**dn,
						 CacheEntry		 *entry);
int	cache_free_cursor			(MDB_cursor		 *cur);
void	cache_close				(void);

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





struct cache_entry_header {
	u_int16_t type;
	size_t key_size;
	size_t data_size;
};


void hex_dump(int level, void *data, size_t start, size_t size)
{
	int i;
	int pos;

		snprintf(str+pos    , 80-pos    , "%c", isprint(((char*)data+start)[i]) ? ((char*)data+start)[i] : '?');
		pos+=1;
		if ((i+1) % per_line == 0) {
			univention_debug(UV_DEBUG_LISTENER, level, "%s| %s (%08zu)", hex, str, start+i-per_line);
			//fprintf(stderr, "%s| %s (%08d)\n", hex, str, start+i-per_line);
			memset(hex, 0, 80);
			memset(str, 0, 80);

}

/* assumption: enough memory as been allocated for us */
static int append_buffer(void **data, size_t *size, size_t *pos, void* blob_data, size_t blob_size)
{
	if (blob_size > 0) {
		memcpy((void*)(((char*)*data)+*pos), blob_data, blob_size);
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "position was=%zu is=%zu", *pos, *pos+blob_size);
		*pos += blob_size;
	}
	return 0;
}

static int write_header(void **data, size_t *size, size_t *pos, u_int16_t type, void* key_data, size_t key_size, void* data_data, size_t data_size)
{
	struct cache_entry_header h;
	size_t need_memory;

	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "write_header key_size=%zu data_size=%zu", key_size, data_size);

	need_memory = sizeof(struct cache_entry_header)+key_size+data_size;
	if (*size < *pos+need_memory) {

	return 0;
}

int unparse_entry(void **data, size_t *size, CacheEntry *entry)
{
	CacheEntryAttribute **attribute;
	char **value;

	char **module;
	int *length;
	int i;
	size_t pos=0;

	for (attribute=entry->attributes; attribute != NULL && *attribute != NULL; attribute++) {
		for (value=(*attribute)->values, i=0, length=(*attribute)->length; *value != NULL; value++, i++) {

	return 0;
}

static int read_header(void *data, size_t size, size_t *pos, void **key_data, size_t *key_size, void **data_data, size_t *data_size)
{
	struct cache_entry_header *h;

	if (*pos == size) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "end of buffer pos=size=%zu", *pos);
		return 0;
	} else if (*pos+sizeof(struct cache_entry_header) > size) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "buffer exceeded pos=%zu size=%zu", *pos, size);
		return -1;
	}


	h = (struct cache_entry_header*)((char*)data+*pos);

	if ((h->type != 1 && h->type != 2) || h->key_size == 0) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "read_header pos=%zu type=%d key_size=%zu data_size=%zu", *pos, h->type, h->key_size, h->data_size);
		*key_size = 0;
		*key_data = NULL;
		*data_size = 0;

	}
	*pos += sizeof(struct cache_entry_header);
	if (*pos+h->key_size+h->data_size > size) {
		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "buffer exceeded pos=%zu size=%zu", *pos, size);
		return -1;
	}


		*data_size = 0;
		*data_data = NULL;
	}
	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "read_header pos=%zu type=%d key_size=%zu data_size=%zu key_data=[%s] data_data=[%s]", *pos, h->type, h->key_size, h->data_size, (char*)*key_data, (char*)*data_data);

	return h->type;
}

int parse_entry(void *data, size_t size, CacheEntry *entry)
{
	u_int16_t type;
	void *key_data, *data_data;
	size_t key_size, data_size;
	size_t pos=0;

	entry->attributes=NULL;
	entry->attribute_count=0;

		} else {
			char filename[PATH_MAX];
			FILE *file;
			size_t len;
			int rv;

			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "bad data block at position %zu:", pos);
			len = pos < 1000 ? pos : 1000;
			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "last %zu bytes of previous entry:", len);
			hex_dump(UV_DEBUG_ERROR, data, pos < 1000 ? 0 : pos-1000, len);
			len = pos + 1000 > size ? size-pos : 1000;
			univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "first %zu bytes of current entry:", len);
			hex_dump(UV_DEBUG_ERROR, data, pos, len);

			rv = snprintf(filename, PATH_MAX, "%s/bad_cache", cache_dir);

Lines 36-46 Link Here

(-)src/cache_lowlevel.h (-3 / +3 lines)
36	#include "cache.h"	36	#include "cache.h"
37		37
38	int unparse_entry (void **data,	38	int unparse_entry (void **data,
39	u_int32_t *size,	39	size_t *size,
40	CacheEntry *entry);	40	CacheEntry *entry);
41	int parse_entry (void *data,	41	int parse_entry (void *data,
42	u_int32_t size,	42	size_t size,
43	CacheEntry *entry);	43	CacheEntry *entry);
44	void hex_dump(int level, void *data, u_int32_t start, u_int32_t size);	44	void hex_dump(int level, void *data, size_t start, size_t size);
45		45
46	#endif /* _CACHE_LOWLEVEL_ */	46	#endif /* _CACHE_LOWLEVEL_ */




#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 *dbc_cur = 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(&dbc_cur, &dn, &cache_entry); rv != MDB_NOTFOUND;
			rv=cache_next_entry(&dbc_cur, &dn, &cache_entry)) {
		if (rv == -1) continue;
		if (rv < 0) break;

	/* 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 {

	CacheEntry entry;
	int rv;

	if ((rv = cache_get_entry_lower_upper(dn, &entry)) == MDB_NOTFOUND) {
		signals_block();
		/* run handlers anyway */
		if (handlers_delete(dn, &entry, command) == 0) {

	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_INFO, "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;
	}

Lines 67-73 Link Here

(-)src/dump.c (-2 / +2 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 *cur = NULL;
71	char *dn = NULL;	71	char *dn = NULL;
72	CacheEntry entry;	72	CacheEntry entry;
73		73
Lines 136-142 Link Here
136	printf("%ld %ld\n", cache_master_entry.id, cache_master_entry.schema_id);	136	printf("%ld %ld\n", cache_master_entry.id, cache_master_entry.schema_id);
137	} else {	137	} else {
138		138
139	for (rv=cache_first_entry(&cur, &dn, &entry); rv != DB_NOTFOUND;	139	for (rv=cache_first_entry(&cur, &dn, &entry); rv != MDB_NOTFOUND;
140	rv=cache_next_entry(&cur, &dn, &entry)) {	140	rv=cache_next_entry(&cur, &dn, &entry)) {
141	if ((rv == 0 && !broken_only) \|\| (rv == -1 && broken_only)) {	141	if ((rv == 0 && !broken_only) \|\| (rv == -1 && broken_only)) {
142	cache_dump_entry(dn, &entry, fp);	142	cache_dump_entry(dn, &entry, fp);

Lines 594-600 Link Here

(-)src/main.c (-1 / +1 lines)
594		594
595	/* if no ID is set, assume the database has just been initialized */	595	/* if no ID is set, assume the database has just been initialized */
596	rv = cache_get_master_entry(&cache_master_entry);	596	rv = cache_get_master_entry(&cache_master_entry);
597	if (rv == DB_NOTFOUND) {	597	if (rv == MDB_NOTFOUND) {
598	cache_get_int("notifier_id", &cache_master_entry.id, -1);	598	cache_get_int("notifier_id", &cache_master_entry.id, -1);
599	if (cache_master_entry.id == -1) {	599	if (cache_master_entry.id == -1) {
600	rv = notifier_get_id_s(NULL, &cache_master_entry.id);	600	rv = notifier_get_id_s(NULL, &cache_master_entry.id);




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

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

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


			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 46-57 Link Here

(-)src/cache_lowlevel.c (-24 / +24 lines)
46		46
47	struct cache_entry_header {	47	struct cache_entry_header {
48	u_int16_t type;	48	u_int16_t type;
49	u_int32_t key_size;	49	size_t key_size;
50	u_int32_t data_size;	50	size_t data_size;
51	};	51	};
52		52
53		53
54	void hex_dump(int level, void *data, u_int32_t start, u_int32_t size)	54	void hex_dump(int level, void *data, size_t start, size_t size)
55	{	55	{
56	int i;	56	int i;
57	int pos;	57	int pos;
Lines 68-74 Link Here
68	snprintf(str+pos , 80-pos , "%c", isprint(((char)data+start)[i]) ? ((char)data+start)[i] : '?');	68	snprintf(str+pos , 80-pos , "%c", isprint(((char)data+start)[i]) ? ((char)data+start)[i] : '?');
69	pos+=1;	69	pos+=1;
70	if ((i+1) % per_line == 0) {	70	if ((i+1) % per_line == 0) {
71	univention_debug(UV_DEBUG_LISTENER, level, "%s\| %s (%08d)", hex, str, start+i-per_line);	71	univention_debug(UV_DEBUG_LISTENER, level, "%s\| %s (%08zu)", hex, str, start+i-per_line);
72	//fprintf(stderr, "%s\| %s (%08d)\n", hex, str, start+i-per_line);	72	//fprintf(stderr, "%s\| %s (%08d)\n", hex, str, start+i-per_line);
73	memset(hex, 0, 80);	73	memset(hex, 0, 80);
74	memset(str, 0, 80);	74	memset(str, 0, 80);
Lines 80-101 Link Here
80	}	80	}
81		81
82	/* assumption: enough memory as been allocated for us */	82	/* assumption: enough memory as been allocated for us */
83	static int append_buffer(void *data, u_int32_t size, u_int32_t pos, void blob_data, u_int32_t blob_size)	83	static int append_buffer(void *data, size_t size, size_t pos, void blob_data, size_t blob_size)
84	{	84	{
85	if (blob_size > 0) {	85	if (blob_size > 0) {
86	memcpy((void)(((char)data)+pos), blob_data, blob_size);	86	memcpy((void)(((char)data)+pos), blob_data, blob_size);
87	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "position was=%d is=%d", pos, pos+blob_size);	87	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "position was=%zu is=%zu", pos, pos+blob_size);
88	*pos += blob_size;	88	*pos += blob_size;
89	}	89	}
90	return 0;	90	return 0;
91	}	91	}
92		92
93	static int write_header(void *data, u_int32_t size, u_int32_t pos, u_int16_t type, void key_data, u_int32_t key_size, void* data_data, u_int32_t data_size)	93	static int write_header(void *data, size_t size, size_t pos, u_int16_t type, void key_data, size_t key_size, void* data_data, size_t data_size)
94	{	94	{
95	struct cache_entry_header h;	95	struct cache_entry_header h;
96	u_int32_t need_memory;	96	size_t need_memory;
97		97
98	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "write_header key_size=%d data_size=%d", key_size, data_size);	98	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "write_header key_size=%zu data_size=%zu", key_size, data_size);
99		99
100	need_memory = sizeof(struct cache_entry_header)+key_size+data_size;	100	need_memory = sizeof(struct cache_entry_header)+key_size+data_size;
101	if (size < pos+need_memory) {	101	if (size < pos+need_memory) {
Lines 118-124 Link Here
118	return 0;	118	return 0;
119	}	119	}
120		120
121	int unparse_entry(void *data, u_int32_t size, CacheEntry *entry)	121	int unparse_entry(void *data, size_t size, CacheEntry *entry)
122	{	122	{
123	CacheEntryAttribute **attribute;	123	CacheEntryAttribute **attribute;
124	char **value;	124	char **value;
Lines 125-131 Link Here
125	char **module;	125	char **module;
126	int *length;	126	int *length;
127	int i;	127	int i;
128	u_int32_t pos=0;	128	size_t pos=0;
129		129
130	for (attribute=entry->attributes; attribute != NULL && *attribute != NULL; attribute++) {	130	for (attribute=entry->attributes; attribute != NULL && *attribute != NULL; attribute++) {
131	for (value=(attribute)->values, i=0, length=(attribute)->length; *value != NULL; value++, i++) {	131	for (value=(attribute)->values, i=0, length=(attribute)->length; *value != NULL; value++, i++) {
Lines 146-160 Link Here
146	return 0;	146	return 0;
147	}	147	}
148		148
149	static int read_header(void data, u_int32_t size, u_int32_t pos, void *key_data, u_int32_t key_size, void *data_data, u_int32_t data_size)	149	static int read_header(void data, size_t size, size_t pos, void *key_data, size_t key_size, void *data_data, size_t data_size)
150	{	150	{
151	struct cache_entry_header *h;	151	struct cache_entry_header *h;
152		152
153	if (*pos == size) {	153	if (*pos == size) {
154	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "end of buffer pos=size=%d", *pos);	154	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "end of buffer pos=size=%zu", *pos);
155	return 0;	155	return 0;
156	} else if (*pos+sizeof(struct cache_entry_header) > size) {	156	} else if (*pos+sizeof(struct cache_entry_header) > size) {
157	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "buffer exceeded pos=%d size=%d", *pos, size);	157	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "buffer exceeded pos=%zu size=%zu", *pos, size);
158	return -1;	158	return -1;
159	}	159	}
160		160
Lines 161-167 Link Here
161	h = (struct cache_entry_header)((char)data+*pos);	161	h = (struct cache_entry_header)((char)data+*pos);
162		162
163	if ((h->type != 1 && h->type != 2) \|\| h->key_size == 0) {	163	if ((h->type != 1 && h->type != 2) \|\| h->key_size == 0) {
164	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "read_header pos=%d type=%d key_size=%d data_size=%d", *pos, h->type, h->key_size, h->data_size);	164	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "read_header pos=%zu type=%d key_size=%zu data_size=%zu", *pos, h->type, h->key_size, h->data_size);
165	*key_size = 0;	165	*key_size = 0;
166	*key_data = NULL;	166	*key_data = NULL;
167	*data_size = 0;	167	*data_size = 0;
Lines 170-176 Link Here
170	}	170	}
171	*pos += sizeof(struct cache_entry_header);	171	*pos += sizeof(struct cache_entry_header);
172	if (*pos+h->key_size+h->data_size > size) {	172	if (*pos+h->key_size+h->data_size > size) {
173	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "buffer exceeded pos=%d size=%d", *pos, size);	173	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "buffer exceeded pos=%zu size=%zu", *pos, size);
174	return -1;	174	return -1;
175	}	175	}
176		176
Lines 186-202 Link Here
186	*data_size = 0;	186	*data_size = 0;
187	*data_data = NULL;	187	*data_data = NULL;
188	}	188	}
189	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "read_header pos=%d type=%d key_size=%d data_size=%d key_data=[%s] data_data=[%s]", pos, h->type, h->key_size, h->data_size, (char)key_data, (char)*data_data);	189	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "read_header pos=%zu type=%d key_size=%zu data_size=%zu key_data=[%s] data_data=[%s]", pos, h->type, h->key_size, h->data_size, (char)key_data, (char)*data_data);
190		190
191	return h->type;	191	return h->type;
192	}	192	}
193		193
194	int parse_entry(void data, u_int32_t size, CacheEntry entry)	194	int parse_entry(void data, size_t size, CacheEntry entry)
195	{	195	{
196	u_int16_t type;	196	u_int16_t type;
197	void key_data, data_data;	197	void key_data, data_data;
198	u_int32_t key_size, data_size;	198	size_t key_size, data_size;
199	u_int32_t pos=0;	199	size_t pos=0;
200		200
201	entry->attributes=NULL;	201	entry->attributes=NULL;
202	entry->attribute_count=0;	202	entry->attribute_count=0;
Lines 265-279 Link Here
265	} else {	265	} else {
266	char filename[PATH_MAX];	266	char filename[PATH_MAX];
267	FILE *file;	267	FILE *file;
268	u_int32_t len;	268	size_t len;
269	int rv;	269	int rv;
270		270
271	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "bad data block at position %d:", pos);	271	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "bad data block at position %zu:", pos);
272	len = pos < 1000 ? pos : 1000;	272	len = pos < 1000 ? pos : 1000;
273	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "last %d bytes of previous entry:", len);	273	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "last %zu bytes of previous entry:", len);
274	hex_dump(UV_DEBUG_ERROR, data, pos < 1000 ? 0 : pos-1000, len);	274	hex_dump(UV_DEBUG_ERROR, data, pos < 1000 ? 0 : pos-1000, len);
275	len = pos + 1000 > size ? size-pos : 1000;	275	len = pos + 1000 > size ? size-pos : 1000;
276	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "first %d bytes of current entry:", len);	276	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "first %zu bytes of current entry:", len);
277	hex_dump(UV_DEBUG_ERROR, data, pos, len);	277	hex_dump(UV_DEBUG_ERROR, data, pos, len);
278		278
279	rv = snprintf(filename, PATH_MAX, "%s/bad_cache", cache_dir);	279	rv = snprintf(filename, PATH_MAX, "%s/bad_cache", cache_dir);

Lines 33-39 Link Here

(-)src/cache.h (-6 / +6 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 53-59 Link Here
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 73-86 Link Here
73	int cache_get_entry_lower_upper(	73	int cache_get_entry_lower_upper(
74	char *dn,	74	char *dn,
75	CacheEntry *entry);	75	CacheEntry *entry);
76	int cache_first_entry (DBC **cur,	76	int cache_first_entry (MDB_cursor **cur,
77	char **dn,	77	char **dn,
78	CacheEntry *entry);	78	CacheEntry *entry);
79	int cache_next_entry (DBC **cur,	79	int cache_next_entry (MDB_cursor **cur,
80	char **dn,	80	char **dn,
81	CacheEntry *entry);	81	CacheEntry *entry);
82	int cache_free_cursor (DBC *cur);	82	int cache_free_cursor (MDB_cursor *cur);
83	int cache_close (void);	83	void cache_close (void);
84		84
85	/* deprecated with DB42*/	85	/* deprecated with DB42*/
86	int cache_set_int (char *key,	86	int cache_set_int (char *key,

Lines 40-46 Link Here

(-)src/change.c (-9 / +8 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 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 *dbc_cur = NULL;
78	char *dn = NULL;	78	char *dn = NULL;
79	int i;	79	int i;
80	bool abort_init = false;	80	bool abort_init = false;
Lines 93-99 Link Here
93	/* remove old entries for module */	93	/* remove old entries for module */
94	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_INFO,	94	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_INFO,
95	"remove old entries for module %s", handler->name);	95	"remove old entries for module %s", handler->name);
96	for (rv=cache_first_entry(&dbc_cur, &dn, &cache_entry); rv != DB_NOTFOUND;	96	for (rv=cache_first_entry(&dbc_cur, &dn, &cache_entry); rv != MDB_NOTFOUND;
97	rv=cache_next_entry(&dbc_cur, &dn, &cache_entry)) {	97	rv=cache_next_entry(&dbc_cur, &dn, &cache_entry)) {
98	if (rv == -1) continue;	98	if (rv == -1) continue;
99	if (rv < 0) break;	99	if (rv < 0) break;
Lines 112-118 Link Here
112	/* initialize schema; if it's not in cache yet (it really should be), it'll	112	/* 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 */	113	be initialized on the regular schema check after ldapsearches */
114	if ((rv = cache_get_entry_lower_upper("cn=Subschema", &cache_entry)) != 0 &&	114	if ((rv = cache_get_entry_lower_upper("cn=Subschema", &cache_entry)) != 0 &&
115	rv != DB_NOTFOUND) {	115	rv != MDB_NOTFOUND) {
116	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_WARN,	116	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_WARN,
117	"error while reading from database");	117	"error while reading from database");
118	return LDAP_OTHER;	118	return LDAP_OTHER;
Lines 183-189 Link Here
183	for (i=0; i<dn_count; i++) {	183	for (i=0; i<dn_count; i++) {
184	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "DN: %s", dns[i].dn);	184	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ALL, "DN: %s", dns[i].dn);
185		185
186	if ((rv = cache_get_entry_lower_upper(dns[i].dn, &cache_entry)) == DB_NOTFOUND) { /* XXX */	186	if ((rv = cache_get_entry_lower_upper(dns[i].dn, &cache_entry)) == MDB_NOTFOUND) { /* XXX */
187	LDAPMessage res2, first;	187	LDAPMessage res2, first;
188	int attrsonly0 = 0;	188	int attrsonly0 = 0;
189	rv = LDAP_RETRY(lp, ldap_search_ext_s(lp->ld, dns[i].dn, LDAP_SCOPE_BASE, "(objectClass=*)", attrs, attrsonly0, serverctrls, clientctrls, &timeout, sizelimit0, &res2));	189	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 243-249 Link Here
243	}	243	}
244	}	244	}
245	INIT_ONLY = old_init_only;	245	INIT_ONLY = old_init_only;
246	cache_sync();
247		246
248	return 0;	247	return 0;
249	}	248	}
Lines 264-270 Link Here
264	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_WARN, "error while converting LDAP entry to cache entry");	263	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_WARN, "error while converting LDAP entry to cache entry");
265	goto result;	264	goto result;
266	}	265	}
267	if ((rv = cache_get_entry_lower_upper(dn, &old_cache_entry)) != 0 && rv != DB_NOTFOUND) {	266	if ((rv = cache_get_entry_lower_upper(dn, &old_cache_entry)) != 0 && rv != MDB_NOTFOUND) {
268	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_WARN, "error while reading from database");	267	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_WARN, "error while reading from database");
269	rv = LDAP_OTHER;	268	rv = LDAP_OTHER;
270	} else {	269	} else {
Lines 290-296 Link Here
290	CacheEntry entry;	289	CacheEntry entry;
291	int rv;	290	int rv;
292		291
293	if ((rv = cache_get_entry_lower_upper(dn, &entry)) == DB_NOTFOUND) {	292	if ((rv = cache_get_entry_lower_upper(dn, &entry)) == MDB_NOTFOUND) {
294	signals_block();	293	signals_block();
295	/* run handlers anyway */	294	/* run handlers anyway */
296	if (handlers_delete(dn, &entry, command) == 0) {	295	if (handlers_delete(dn, &entry, command) == 0) {
Lines 703-709 Link Here
703	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_INFO, "updating '%s' command %c", trans->cur.notify.dn, trans->cur.notify.command);	702	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_INFO, "updating '%s' command %c", trans->cur.notify.dn, trans->cur.notify.command);
704		703
705	rv = cache_get_entry_lower_upper(trans->cur.notify.dn, &trans->cur.cache);	704	rv = cache_get_entry_lower_upper(trans->cur.notify.dn, &trans->cur.cache);
706	if (rv != 0 && rv != DB_NOTFOUND) {	705	if (rv != 0 && rv != MDB_NOTFOUND) {
707	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_WARN, "error reading database for %s", trans->cur.notify.dn);	706	univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_WARN, "error reading database for %s", trans->cur.notify.dn);
708	return LDAP_OTHER;	707	return LDAP_OTHER;
709	}	708	}

Lines 140-146 Link Here

(-)src/verify.c (-3 / +3 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 *cur = NULL;
144	char *dn;	144	char *dn;
145	CacheEntry entry;	145	CacheEntry entry;
146	LDAP *ld;	146	LDAP *ld;
Lines 227-233 Link Here
227	if (cache_init() != 0)	227	if (cache_init() != 0)
228	exit(1);	228	exit(1);
229		229
230	for (rv=cache_first_entry(&cur, &dn, &entry); rv != DB_NOTFOUND;	230	for (rv=cache_first_entry(&cur, &dn, &entry); rv != MDB_NOTFOUND;
231	rv=cache_next_entry(&cur, &dn, &entry)) {	231	rv=cache_next_entry(&cur, &dn, &entry)) {
232	if (rv < -1) break;	232	if (rv < -1) break;
233		233
Lines 261-267 Link Here
261	char *dn = ldap_get_dn(ld, cur);	261	char *dn = ldap_get_dn(ld, cur);
262	if (has_dn(dn)) continue;	262	if (has_dn(dn)) continue;
263		263
264	if ((rv = cache_get_entry(dn, &entry)) == DB_NOTFOUND) {	264	if ((rv = cache_get_entry(dn, &entry)) == MDB_NOTFOUND) {
265	printf("E: %s only in LDAP\n", dn);	265	printf("E: %s only in LDAP\n", dn);
266	} else if (rv != 0) {	266	} else if (rv != 0) {
267	printf("E: error reading %s from cache", dn);	267	printf("E: error reading %s from cache", dn);