Attachment #7904 for bug #23367

(-)debian/control (-2 / +3 lines)

Lines 7-13	Link Here

 ucslint-univention,

 ucslint-univention,

 libssl-dev,

 libssl-dev,

 libldap2-dev,

 libldap2-dev,

 libdb3-dev,

 liblmdb-dev,

 python-all-dev,

 python-all-dev,

 libunivention-debug-dev (>= 0.8),

 libunivention-debug-dev (>= 0.8),

 libunivention-config-dev,

 libunivention-config-dev,

Lines 26-32	Link Here

 univention-runit,

 univention-runit,

 python2.7-univention,

 python2.7-univention,

 python2.7-univention-debug,

 python2.7-univention-debug,

 python-univention-lib (>= 1.0.25-1)

 python-univention-lib (>= 1.0.25-1),

 lmdb-utils

Conflicts: univention-ldap-listener (<< 2.2.2)

Conflicts: univention-ldap-listener (<< 2.2.2)

Description: UCS - Directory Listener

Description: UCS - Directory Listener

 UCS Directory Listener is a client for the UCS

 UCS Directory Listener is a client for the UCS

(-)debian/rules (-1 / +1 lines)

Lines 37-43	Link Here

override_dh_auto_build:

override_dh_auto_build:

	$(MAKE) -C src clean

	$(MAKE) -C src clean

	$(MAKE) -C src DB_CFLAGS="-I/usr/include/db3 -DWITH_DB3" DB_LDADD="-ldb3"

	$(MAKE) -C src DB_LDADD="-llmdb"

	dh_auto_build

	dh_auto_build

override_dh_auto_install:

override_dh_auto_install:

(-)debian/univention-directory-listener.postinst (+8 lines)

Lines 45-50	Link Here

	chown listener /var/lib/univention-ldap/listener/listener*

	chown listener /var/lib/univention-ldap/listener/listener*

fi

fi

if [ ! -e /var/lib/univention-directory-listener/cache ]; then

	mkdir /var/lib/univention-directory-listener/cache

	if [ -f /var/lib/univention-directory-listener/cache.db ]; then

		db_dump /var/lib/univention-directory-listener/cache.db | \

			mdb_load /var/lib/univention-directory-listener/cache

fi

fi

#DEBHELPER#

#DEBHELPER#

univention-config-registry set listener/debug/level?2 \

univention-config-registry set listener/debug/level?2 \

(-)src/Makefile (-4 / +3 lines)

Lines 30-40	Link Here

# <http://www.gnu.org/licenses/>.

# <http://www.gnu.org/licenses/>.

CC=gcc

CC=gcc

DB_LDADD=-ldb3

DB_LDADD=-llmdb

DB_CFLAGS=-I/usr/include/db3 -DWITH_DB3

DB_OBJS=cache.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

CFLAGS=-g -Wall -Werror -D_FILE_OFFSET_BITS=64 $(DB_CFLAGS)

CFLAGS=-g -Wall -Werror -D_FILE_OFFSET_BITS=64

LDADD=-g -luniventiondebug -licuuc

LDADD=-g -luniventiondebug -licuuc

LISTENER_LDADD=$(LDADD) -luniventionpolicy -lldap -lpython2.7 $(DB_LDADD)

LISTENER_LDADD=$(LDADD) -luniventionpolicy -lldap -lpython2.7 $(DB_LDADD)

LISTENER_OBJS=main.o notifier.o transfile.o handlers.o change.o network.o signals.o select_server.o utils.o $(DB_OBJS)

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

.PHONY: clean

.PHONY: clean

clean:

clean:

	$(RM) *.o listener dump demo verify *.db3 *.db42

	$(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_cursor *cursor;
	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_cursor_open(txn, dbi, &cursor)) != 0) {
		cache_error_message(rv, "mdb_cursor_open");
		mdb_txn_abort(txn);
		return rv;
	}
	if ((rv = mdb_cursor_get(cursor, &key, &data, MDB_SET_KEY)) == MDB_NOTFOUND) {
		mdb_cursor_close(cursor);
		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_cursor_close(cursor);
		mdb_txn_abort(txn);
		return rv;
	}
	mdb_cursor_close(cursor);
	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);
	*/

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

(-)src/cache_lowlevel.h (-3 / +3 lines)

Lines 36-46	Link Here

#include "cache.h"

#include "cache.h"

int	unparse_entry	(void		**data,

int	unparse_entry	(void		**data,

			 u_int32_t	 *size,

			 size_t		 *size,

			 CacheEntry	 *entry);

			 CacheEntry	 *entry);

int	parse_entry	(void		 *data,

int	parse_entry	(void		 *data,

			 u_int32_t	  size,

			 size_t		  size,

			 CacheEntry	 *entry);

			 CacheEntry	 *entry);

void hex_dump(int level, void *data, u_int32_t start, u_int32_t size);

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

#endif /* _CACHE_LOWLEVEL_ */

#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;
	}

(-)src/dump.c (-2 / +2 lines)

Lines 67-73	Link Here

	char *output_file = NULL;

	char *output_file = NULL;

	FILE *fp;

	FILE *fp;

	int rv;

	int rv;

	DBC *cur;

	MDB_cursor *cur = NULL;

	char *dn = NULL;

	char *dn = NULL;

	CacheEntry entry;

	CacheEntry entry;

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

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

(-)src/main.c (-1 / +1 lines)

Lines 594-600	Link Here

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