Attachment #8495 for bug #35707





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


		abort();

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

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


		free(mapsize_str);

		if ((errno == ERANGE && (mapsize == LONG_MAX || mapsize == LONG_MIN)) || (errno != 0 && mapsize == 0)) {
			LOG(ERROR, "cache_init: Error parsing value of UCR variable %s as number: %s", ucr_var_mapsize, strerror(errno));
			exit(EXIT_FAILURE);
		}
		if (endptr == mapsize_str) {
			LOG(ERROR, "Value of UCR variable %s is not a number", ucr_var_mapsize);
			mapsize = default_mapsize;
			LOG(ERROR, "using default mapsize: %zu", mapsize);
		} else {
			LOG(INFO, "using UCR defined mapsize: %zu", mapsize);
		}
	} else {
		mapsize = default_mapsize;
		LOG(INFO, "using default mapsize: %zu", mapsize);
	}
	return mapsize;
}

	size_t mapsize = determine_mapsize_from_ucr();

	if ((mdb_flags & MDB_RDONLY) != 0) {
		LOG(INFO, "MDB_RDONLY");
		mdb_readonly = MDB_RDONLY;
	} else {
		mdb_dbi_flags |= MDB_CREATE;


	rv = mdb_env_create(&env);
	if (rv != MDB_SUCCESS) {
		LOG(ERROR, "creating environment handle failed");
		ERROR_MDB(rv, "mdb_env_create");
		return rv;
	}

	rv = mdb_env_set_mapsize(env, mapsize);
	if (rv != MDB_SUCCESS) {
		LOG(ERROR, "setting mdb mapsize failed");
		ERROR_MDB(rv, "mdb_env_set_mapsize");
		return rv;
	}

	rv = mdb_env_set_maxdbs(env, 2);
	if (rv != MDB_SUCCESS) {
		LOG(ERROR, "setting mdb maxdbs failed");
		ERROR_MDB(rv, "mdb_env_set_maxdbs");
		return rv;
	}

	rv = mdb_env_open(env, cache_mdb_dir, mdb_readonly, 0600);
	if (rv != MDB_SUCCESS) {
		LOG(ERROR, "opening database failed");
		ERROR_MDB(rv, "mdb_env_open");
		return rv;
	}

	LOG(ALL, "Transaction begin");

	rv = mdb_txn_begin(env, NULL, mdb_readonly, &cache_init_txn);
	if (rv != MDB_SUCCESS) {

		return rv;
	}

	LOG(ALL, "Transaction commit");

	rv = mdb_txn_commit(cache_init_txn);
	if (rv != MDB_SUCCESS) {

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

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

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

	LOG(ALL, "Read Transaction begin");

	rv = mdb_txn_begin(env, NULL, MDB_RDONLY, &read_txn);
	if (rv != MDB_SUCCESS) {


	rv = mdb_get(read_txn, id2entry, &key, &data);
	if (rv == MDB_NOTFOUND) {
		LOG(ALL, "Read Transaction abort: %s",
		    mdb_strerror(rv));
		                 mdb_strerror(rv));
		mdb_txn_abort(read_txn);
		return rv;
	} else if (rv != MDB_SUCCESS) {
		LOG(ERROR, "reading master entry from database failed");
		ERROR_MDB(rv, "mdb_get");
		mdb_txn_abort(read_txn);
		return rv;
	}

	LOG(ALL, "Read Transaction abort");
	mdb_txn_abort(read_txn);

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


	data.mv_data = (void *)master_entry;
	data.mv_size = sizeof(CacheMasterEntry);

	LOG(ALL, "Transaction begin");
	if ((rv = mdb_txn_begin(env, NULL, 0, &write_txn)) != MDB_SUCCESS) {
		ERROR_MDB(rv, "mdb_txn_begin");
		return rv;
	}
	rv = mdb_put(write_txn, id2entry, &key, &data, 0);
	if (rv != MDB_SUCCESS) {
		LOG(ERROR, "storing master entry in database failed");
		ERROR_MDB(rv, "mdb_put");
		mdb_txn_abort(write_txn);
		return rv;
	}
	LOG(ALL, "Transaction commit");
	if ((rv = mdb_txn_commit(write_txn)) != MDB_SUCCESS) {
		LOG(ERROR, "storing master entry in database failed");
		ERROR_MDB(rv, "mdb_txn_commit");
		return rv;
	}

	rv = unparse_entry(&data.mv_data, &tmp_size, entry);
	data.mv_size = tmp_size;
	if (rv != 0) {
		LOG(ERROR, "unparsing entry failed");
		return rv;
	}


	write_txn = mdb_cursor_txn(*id2dn_cursor_pp);
	rv = mdb_put(write_txn, id2entry, &key, &data, 0);
	if (rv != MDB_SUCCESS) {
		LOG(ERROR, "storing entry in database failed: %s", dn);
		ERROR_MDB(rv, "mdb_put");
		goto out;
	}
	LOG(ALL, "put %zu bytes for %s", data.mv_size, dn);

out:
	signals_unblock();

	MDB_txn *write_txn;
	MDB_cursor *id2dn_write_cursor_p;

	LOG(ALL, "Transaction begin");
	rv = mdb_txn_begin(env, NULL, 0, &write_txn);
	if (rv != MDB_SUCCESS) {
		ERROR_MDB(rv, "mdb_txn_begin");

	mdb_cursor_close(id2dn_write_cursor_p);

	if (rv != MDB_SUCCESS) {
		LOG(ALL, "Transaction abort");
		mdb_txn_abort(write_txn);
		return rv;
	}

	LOG(ALL, "Transaction commit");
	rv = mdb_txn_commit(write_txn);
	if (rv != MDB_SUCCESS) {
		LOG(ERROR, "storing updated entry in database failed");
		ERROR_MDB(rv, "mdb_txn_commit");
		return rv;
	}

	int rv = 0;

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


	write_txn = mdb_cursor_txn(*id2dn_cursor_pp);
	rv = mdb_del(write_txn, id2entry, &key, 0);
	if (rv != MDB_SUCCESS && rv != MDB_NOTFOUND) {
		LOG(ERROR, "removing from database failed: %s", dn);
		ERROR_MDB(rv, "ERROR_MDB: mdb_del");
		signals_unblock();
		return rv;

	MDB_txn *write_txn;
	MDB_cursor *id2dn_write_cursor_p;

	LOG(ALL, "Transaction begin");
	rv = mdb_txn_begin(env, NULL, 0, &write_txn);
	if (rv != MDB_SUCCESS) {
		ERROR_MDB(rv, "mdb_txn_begin");

	mdb_cursor_close(id2dn_write_cursor_p);

	if (rv != MDB_SUCCESS) {
		LOG(ALL, "Transaction abort");
		mdb_txn_abort(write_txn);
		return rv;
	}

	LOG(ALL, "Transaction commit");
	rv = mdb_txn_commit(write_txn);
	if (rv != MDB_SUCCESS) {
		LOG(ERROR, "storing entry removal from database failed");
		ERROR_MDB(rv, "mdb_txn_commit");
	}


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

	LOG(ALL, "Read Transaction begin");

	rv = mdb_txn_begin(env, NULL, MDB_RDONLY, &read_txn);
	if (rv != MDB_SUCCESS) {

	rv = dntree_get_id4dn(id2dn_read_cursor_p, dn, &dnid, false);
	mdb_cursor_close(id2dn_read_cursor_p);
	if (rv == MDB_NOTFOUND) {
		LOG(ALL, "Read Transaction abort");
		mdb_txn_abort(read_txn);
		return rv;
	}

	rv = mdb_get(read_txn, id2entry, &key, &data);
	// signals_unblock();

	LOG(ALL, "Read Transaction abort");
	mdb_txn_abort(read_txn);

	if (rv == MDB_SUCCESS) {
		LOG(INFO, "got %zu bytes for %s", data.mv_size, dn);
	} else if (rv == MDB_NOTFOUND) {
		LOG(INFO, "no cache entry found for %s", dn);
		return rv;
	} else {
		LOG(ERROR, "reading %s from database failed", dn);
		ERROR_MDB(rv, "mdb_get");
		return rv;
	}

	assert(data.mv_size <= UINT32_MAX);
	rv = parse_entry(data.mv_data, data.mv_size, entry);
	if (rv != 0) {
		LOG(ERROR, "parsing entry failed");
		exit(1);
	}


	MDB_txn *read_txn;
	int rv;

	LOG(ALL, "Transaction begin");

	rv = mdb_txn_begin(env, NULL, mdb_readonly, &read_txn);
	if (rv != MDB_SUCCESS) {

	MDB_envinfo stat;
	MDB_env *env = mdb_txn_env(read_txn);
	mdb_env_info(env, &stat);
	LOG(ALL, "LAST COMMITTED TXN: %zu", stat.me_last_txnid);
	        "LAST COMMITTED TXN: %zu", stat.me_last_txnid);
	*/

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

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

	LOG(ALL, "got %zu bytes", data.mv_size);

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


	rv = dntree_lookup_dn4id(*id2dn_read_cursor_pp, dnid, dn);
	if (rv != MDB_SUCCESS) {
		LOG(ERROR, "DB corruption, DN entry for id %d not found", *(int *)key.mv_data);
		ERROR_MDB(rv, "mdb_get");
		return rv;
	}

	mdb_cursor_close(id2entry_read_cursor_pp);
	mdb_cursor_close(id2dn_read_cursor_pp);

	LOG(ALL, "Transaction commit");
	rv = mdb_txn_commit(read_txn);
	if (rv != MDB_SUCCESS) {
		LOG(ERROR, "Transation commit failed");
		ERROR_MDB(rv, "mdb_txn_commit");
	}
	return rv;




#include <stdbool.h>
#include <assert.h>

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

#include "common.h"

#endif

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

int bdb_cache_lock(void) {

		abort();

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

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



#ifdef WITH_DB42
	if ((rv = db_env_create(&dbenvp, 0)) != 0) {
		LOG(ERROR, "creating database environment failed");
		return rv;
	}
	dbenvp->set_errcall(dbenvp, bdb_cache_error_message);

	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) {
		LOG(ERROR, "opening database environment failed");
		dbenvp->err(dbenvp, rv, "%s", "environment");
		return rv;
	}
	if ((rv = db_create(&dbp, dbenvp, 0)) != 0) {
		LOG(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) {
		LOG(ERROR, "opening database failed");
		dbp->err(dbp, rv, "open");
		// FIXME: free dbp
		return rv;
	}
#else
	if ((rv = db_create(&dbp, NULL, 0)) != 0) {
		LOG(ERROR, "creating database handle failed");
		return rv;
	}
	if ((rv = dbp->open(dbp, file, NULL, DB_BTREE, DB_CREATE, 0600)) != 0) {
		LOG(ERROR, "opening database failed");
		dbp->err(dbp, rv, "open");
		// FIXME: free dbp
		return rv;

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

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

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

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


		flags = 0;

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

			old_id = &master_entry.id;

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

#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

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

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


	signals_block();
#ifdef WITH_DB42
	dbtxnp = bdb_cache_new_transaction(id, dn);


	if ((rv = dbp->put(dbp, dbtxnp, &key, &data, 0)) != 0) {
		signals_unblock();
		LOG(ERROR, "storing entry in database failed: %s", dn);
		dbp->err(dbp, rv, "put");
#ifdef WITH_DB42
		dbtxnp->abort(dbtxnp);

		free(data.data);
		return rv;
	}
	LOG(ALL, "put %d bytes for %s", data.size, dn);


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

	int rv = 0;

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



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


	signals_unblock();

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

	LOG(ALL, "got %d bytes for %s", data.size, dn);

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

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

	LOG(ALL, "got %d bytes", data.size);

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

	dbp = NULL;
#ifdef WITH_DB42
	if ((rv = dbenvp->close(dbenvp, 0)) != 0) {
		LOG(ERROR, "closing database environment failed");
	}
#endif
	if (lock_fp != NULL) {




#include <sys/stat.h>
#include <unistd.h>
#include <assert.h>

#include "cache_dn.h"
#include "common.h"

static int mdb_dupsort(const MDB_val *a, const MDB_val *b) {
	int diff;

	for (iRDN--; iRDN >= 0; iRDN--) {
		rv = ldap_rdn2str(dn[iRDN], &rdn, LDAP_DN_FORMAT_LDAPV3);
		if (rv != LDAP_SUCCESS) {
			LOG(ERROR, "ldap_rdn2str failed: %s (%d)", ldap_err2string(rv), rv);
			return rv;
		}


		data.mv_size = sizeof(subDN) + strlen(rdn);
		subdn = calloc(1, data.mv_size);
		if (subdn == NULL) {
			LOG(ERROR, "calloc failed");
			ldap_memfree(rdn);
			abort();
		}

			break;
		}
		if (rv != MDB_SUCCESS) {
			LOG(ERROR, "mdb_cursor_get failed: %s (%d)", ldap_err2string(rv), rv);
			return rv;
		};


	}

	if (rv == MDB_SUCCESS) {
		LOG(INFO, "found id=%lu", id);
	} else if (rv != MDB_NOTFOUND) {
		LOG(ERROR, "failed: %s (%d)", mdb_strerror(rv), rv);
	}

	*dnid_out = id;

	data.mv_size = 0;

	if (rv != MDB_SUCCESS) {
		LOG(ERROR, "mdb_cursor_get (MDB_GET_BOTH): %s (%d)", 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) {
		LOG(ERROR, "mdb_cursor_get: %s (%d)", mdb_strerror(rv), rv);
		return rv;
	};


	dbi = mdb_cursor_dbi(cur);
	rv = mdb_get(txn, dbi, &key, &data);
	if (rv != MDB_SUCCESS) {
	        LOG(ERROR, "mdb_get: %s (%d)", mdb_strerror(rv), rv);
	                "%s: mdb_get: %s (%d)",
	                __func__, mdb_strerror(rv), rv);
	        return rv;
	};
	*/


	*dn = strdup(subdn->data);
	if (*dn == NULL) {
		LOG(ERROR, "strdup failed");
		abort();
	}


		*dnid_out = 1;
		return MDB_SUCCESS;
	} else {
		LOG(ERROR, "mdb_cursor_get: %s (%d)", mdb_strerror(rv), rv);
		return rv;
	}
}


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

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

	LOG(INFO, "child=%lu, parent=%lu: \"%s\"", child, parent, rdn_str);

	dn_len = strlen(dn_str);
	subdn = calloc(1, sizeof(subDN) + dn_len);
	if (subdn == NULL) {
		LOG(ERROR, "calloc failed");
		ldap_memfree(dn_str);
		ldap_memfree(rdn_str);
		abort();


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

	dbi = mdb_cursor_dbi(write_cursor_p);
	rv = mdb_cursor_open(txn, dbi, &local_read_cursor_p);
	if (rv != MDB_SUCCESS) {
		LOG(ERROR, "mdb_cursor_open: %s (%d)", ldap_err2string(rv), rv);
		return rv;
	}

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

		if (num_rdns(pdn) != found) {
			rv = dntree_get_id4ldapdn(write_cursor_p, pdn, &parent);
			if (rv != MDB_SUCCESS) {
				LOG(ERROR, "failed: %s (%d)", mdb_strerror(rv), rv);
				return rv;
			}
		} else {


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

	if (ldapdn == NULL) {
		LOG(ERROR, "ldap_str2dn NULL: %s (%d): %s", ldap_err2string(rv), rv, dn);
		return 1;
	}

	if (create == true) {
		rv = dntree_get_id4ldapdn(id2dn_cursor_p, ldapdn, dnid);
		if (rv != MDB_SUCCESS) {
			LOG(ERROR, "failed for: %s", dn);
		}

	} else {
		rv = dntree_lookup_id4ldapdn(id2dn_cursor_p, ldapdn, dnid, NULL);
		if (rv == MDB_NOTFOUND) {
			LOG(INFO, "DN %s not in id2dn", dn);
		}
	}


	bool readonly = (mdb_flags & MDB_RDONLY) != 0;

	if (readonly) {
		LOG(INFO, "dntree_init: MDB_RDONLY");
	} else {
		mdb_dbi_flags |= MDB_CREATE;
	}

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



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





#include <assert.h>
#include <ldap.h>

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

#include "cache_entry.h"

		struct berval **val, **v;

		if ((cache_entry->attributes = realloc(cache_entry->attributes, (cache_entry->attribute_count + 2) * sizeof(CacheEntryAttribute *))) == NULL) {
			LOG(ERROR, "realloc of attributes array failed");
			rv = 1;
			goto result;
		}
		if ((cache_entry->attributes[cache_entry->attribute_count] = malloc(sizeof(CacheEntryAttribute))) == NULL) {
			LOG(ERROR, "malloc for CacheEntryAttribute failed");
			rv = 1;
			goto result;
		}

			}
		}
		if ((val = ldap_get_values_len(ld, ldap_entry, attr)) == NULL) {
			LOG(ERROR, "ldap_get_values failed");
			rv = 1;
			goto result;
		}
		for (v = val; *v != NULL; v++) {
			if ((*v)->bv_val == NULL) {
				// check here, strlen behavior might be undefined in this case
				LOG(ERROR, "ignoring bv_val of NULL with bv_len=%ld, ignoring, check attribute: %s of DN: %s",
				    (*v)->bv_len, cache_entry->attributes[cache_entry->attribute_count]->name, *dn);
				rv = 1;
				goto result;
			}

				duplicateMemberUid = 0;
				for (i = 0; i < cache_entry->attributes[cache_entry->attribute_count]->value_count; i++) {
					if (!memcmp(cache_entry->attributes[cache_entry->attribute_count]->values[i], (*v)->bv_val, (*v)->bv_len + 1)) {
						LOG(ERROR, "Found a duplicate memberUid entry:");
						LOG(ERROR, "DN: %s", *dn);
						LOG(ERROR, "memberUid: %s", cache_entry->attributes[cache_entry->attribute_count]->values[i]);
						duplicateMemberUid = true;
						break;
					}

				duplicateUniqueMember = false;
				for (i = 0; i < cache_entry->attributes[cache_entry->attribute_count]->value_count; i++) {
					if (!memcmp(cache_entry->attributes[cache_entry->attribute_count]->values[i], (*v)->bv_val, (*v)->bv_len + 1)) {
						LOG(ERROR, "Found a duplicate uniqueMember entry:");
						LOG(ERROR, "DN: %s", *dn);
						LOG(ERROR, "uniqueMember: %s", cache_entry->attributes[cache_entry->attribute_count]->values[i]);
						duplicateUniqueMember = true;
						break;
					}

			}
			if ((cache_entry->attributes[cache_entry->attribute_count]->values =
			         realloc(cache_entry->attributes[cache_entry->attribute_count]->values, (cache_entry->attributes[cache_entry->attribute_count]->value_count + 2) * sizeof(char *))) == NULL) {
				LOG(ERROR, "realloc of values array failed");
				rv = 1;
				goto result;
			}
			if ((cache_entry->attributes[cache_entry->attribute_count]->length =
			         realloc(cache_entry->attributes[cache_entry->attribute_count]->length, (cache_entry->attributes[cache_entry->attribute_count]->value_count + 2) * sizeof(int))) == NULL) {
				LOG(ERROR, "realloc of length array failed");
				rv = 1;
				goto result;
			}
			if ((*v)->bv_len == strlen((*v)->bv_val)) {
				if ((cache_entry->attributes[cache_entry->attribute_count]->values[cache_entry->attributes[cache_entry->attribute_count]->value_count] = strdup((*v)->bv_val)) == NULL) {
					LOG(ERROR, "strdup of value failed");
					rv = 1;
					goto result;
				}

				// the legacy approach is to copy bv_len bytes, let's stick with this and just terminate to be safe
				if ((cache_entry->attributes[cache_entry->attribute_count]->values[cache_entry->attributes[cache_entry->attribute_count]->value_count] = malloc(((*v)->bv_len + 1) * sizeof(char))) ==
				    NULL) {
					LOG(ERROR, "malloc for value failed");
					rv = 1;
					goto result;
				}

	memset(backup_cache_entry, 0, sizeof(CacheEntry));
	for (cur1 = cache_entry->attributes; cur1 != NULL && *cur1 != NULL; cur1++) {
		if ((backup_cache_entry->attributes = realloc(backup_cache_entry->attributes, (backup_cache_entry->attribute_count + 2) * sizeof(CacheEntryAttribute *))) == NULL) {
			LOG(ERROR, "realloc of attributes array failed");
			rv = 1;
			goto result;
		}
		if ((backup_cache_entry->attributes[backup_cache_entry->attribute_count] = malloc(sizeof(CacheEntryAttribute))) == NULL) {
			LOG(ERROR, "malloc for CacheEntryAttribute failed");
			rv = 1;
			goto result;
		}


		for (i = 0; i < (*cur1)->value_count; i++) {
			if (((*cur2)->values = realloc((*cur2)->values, ((*cur2)->value_count + 2) * sizeof(char *))) == NULL) {
				LOG(ERROR, "realloc of values array failed");
				rv = 1;
				goto result;
			}
			if (((*cur2)->length = realloc((*cur2)->length, ((*cur2)->value_count + 2) * sizeof(int))) == NULL) {
				LOG(ERROR, "realloc of length array failed");
				rv = 1;
				goto result;
			}
			if ((*cur1)->length[i] == strlen((*cur1)->values[i]) + 1) {
				if (((*cur2)->values[(*cur2)->value_count] = strdup((*cur1)->values[i])) == NULL) {
					LOG(ERROR, "strdup of value failed");
					rv = 1;
					goto result;
				}
				(*cur2)->length[(*cur2)->value_count] = strlen((*cur2)->values[(*cur2)->value_count]) + 1;
			} else {
				if (((*cur2)->values[(*cur2)->value_count] = malloc(((*cur1)->length[i]) * sizeof(char))) == NULL) {
					LOG(ERROR, "malloc for value failed");
					rv = 1;
					goto result;
				}


	tmp = realloc(attr->values, (attr->value_count + 2) * sizeof(char *));
	if (!tmp) {
		LOG(ERROR, "realloc() failed");
		return NULL;
	}
	attr->values = tmp;

	tmp = realloc(attr->length, (attr->value_count + 2) * sizeof(int));
	if (!tmp) {
		LOG(ERROR, "realloc() failed");
		return NULL;
	}
	attr->length = tmp;

	attr->length[attr->value_count] = BER2STR(&ava->la_value, &attr->values[attr->value_count]) + 1;
	if (!attr->values[attr->value_count]) {
		LOG(ERROR, "BER2STR() failed");
		return NULL;
	}
	attr->value_count++;

static CacheEntryAttribute *_cache_entry_add_new_attribute(CacheEntry *entry, LDAPAVA *ava) {
	CacheEntryAttribute *attr = malloc(sizeof(CacheEntryAttribute));
	if (!attr) {
		LOG(ERROR, "malloc() failed");
		return NULL;
	}
	memset(attr, 0, sizeof(CacheEntryAttribute));

	void *tmp = realloc(entry->attributes, (entry->attribute_count + 2) * sizeof(CacheEntryAttribute *));
	if (!tmp) {
		LOG(ERROR, "realloc() failed");
		goto error;
	}
	entry->attributes = tmp;

	BER2STR(&ava->la_attr, &attr->name);
	if (!&attr->name) {
		LOG(ERROR, "BER2STR() failed");
		goto error;
	}
	if (!_cache_entry_force_value(attr, ava))




#include <errno.h>
#include <sys/types.h>

#include <univention/debug.h>

#include "common.h"
#include "cache_lowlevel.h"


};


static void hex_dump(void *data, u_int32_t start, u_int32_t size) {
	int i;
	int pos;
	char hex[80];

	const int per_line = 10;

	pos = 0;
	memset(hex, 0, sizeof(hex));
	memset(str, 0, sizeof(str));

	for (i = 0; i < size; i++) {
		snprintf(hex + (pos * 3), 80 - (pos * 3), "%02x ", ((u_int8_t *)data + start)[i]);
		snprintf(str + pos, 80 - pos, "%c", isprint(((char *)data + start)[i]) ? ((char *)data + start)[i] : '?');
		pos += 1;
		if ((i + 1) % per_line == 0) {
			LOG(ERROR, "%s | %s (%08d)", hex, str, start + i - per_line);
			// fprintf(stderr, "%s| %s (%08d)\n", hex, str, start+i-per_line);
			memset(hex, 0, sizeof(hex));
			memset(str, 0, sizeof(str));
			pos = 0;
		}
	}
	if (pos != 0)
		LOG(ERROR, "%s | %s", hex, str);
}

/* assumption: enough memory as been allocated for us */
static int append_buffer(void **data, u_int32_t *pos, void *blob_data, u_int32_t blob_size) {
	if (blob_size > 0) {
		memcpy((void *)(((char *)*data) + *pos), blob_data, blob_size);
		LOG(ALL, "position was=%d is=%d", *pos, *pos + blob_size);
		*pos += blob_size;
	}
	return 0;

	struct cache_entry_header h;
	u_int32_t need_memory;

	LOG(ALL, "key_size=%d data_size=%d", key_size, data_size);

	need_memory = sizeof(struct cache_entry_header) + key_size + data_size;
	if (*size < *pos + need_memory) {
		while (*size < *pos + need_memory)
			*size += BUFSIZ;
		if ((*data = realloc(*data, *size)) == NULL) {
			LOG(ERROR, "failed to allocate memory");
			return 1;
		}
	}

	struct cache_entry_header *h;

	if (*pos == size) {
		LOG(ALL, "end of buffer pos=size=%d", *pos);
		return 0;
	} else if (*pos + sizeof(struct cache_entry_header) > size) {
		LOG(ERROR, "buffer exceeded pos=%d size=%d", *pos, size);
		return -1;
	}

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

	if ((h->type != 1 && h->type != 2) || h->key_size == 0) {
		LOG(ALL, "pos=%d type=%d key_size=%d data_size=%d", *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) {
		LOG(ERROR, "buffer exceeded pos=%d size=%d", *pos, size);
		return -1;
	}


		*data_size = 0;
		*data_data = NULL;
	}
	LOG(ALL, "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);

	return h->type;
}

		if (type == 1) {
			CacheEntryAttribute **attribute, *c_attr;

			LOG(ALL, "attribute is \"%s\"", (char *)key_data);

			for (attribute = entry->attributes, c_attr = NULL; attribute != NULL && *attribute != NULL; attribute++) {
				LOG(ALL, "current attribute is \"%s\"", (*attribute)->name);
				if (strcmp((*attribute)->name, (char *)key_data) == 0) {
					c_attr = *attribute;
					break;

			}
			if (!c_attr) {
				if (!(entry->attributes = realloc(entry->attributes, (entry->attribute_count + 2) * sizeof(CacheEntryAttribute *)))) {
					LOG(ERROR, "realloc failed");
					abort();  // FIXME
				}
				if (!(c_attr = malloc(sizeof(CacheEntryAttribute)))) {
					LOG(ERROR, "malloc failed");
					abort();  // FIXME
				}
				if (!(c_attr->name = strndup((char *)key_data, key_size))) {
					LOG(ERROR, "strndup failed");
					abort();  // FIXME
				}
				c_attr->values = NULL;

				entry->attributes[entry->attribute_count++] = c_attr;
				entry->attributes[entry->attribute_count] = NULL;

				LOG(ALL, "%s is at %p", c_attr->name, c_attr);
			}
			if (!(c_attr->values = realloc(c_attr->values, (c_attr->value_count + 2) * sizeof(char *)))) {
				LOG(ERROR, "realloc failed");
				abort();  // FIXME
			}
			if (!(c_attr->length = realloc(c_attr->length, (c_attr->value_count + 2) * sizeof(int)))) {
				LOG(ERROR, "realloc failed");
				abort();  // FIXME
			}
			if (!(c_attr->values[c_attr->value_count] = malloc(data_size))) {
				LOG(ERROR, "malloc() failed");
				abort();  // FIXME
			}
			c_attr->length[c_attr->value_count] = data_size;
			memcpy(c_attr->values[c_attr->value_count], data_data, data_size);
			LOG(ALL, "value is \"%s\"", c_attr->values[c_attr->value_count]);
			c_attr->values[++c_attr->value_count] = NULL;
		} else if (type == 2) {
			entry->modules = realloc(entry->modules, (entry->module_count + 2) * sizeof(char *));
			if (!(entry->modules[entry->module_count] = strndup((char *)key_data, key_size))) {
				LOG(ERROR, "strndup failed");
				abort();  // FIXME
			}
			entry->modules[++entry->module_count] = NULL;

			u_int32_t len;
			int rv;

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

			rv = snprintf(filename, PATH_MAX, "%s/bad_cache", cache_dir);
			if (rv < 0 || rv >= PATH_MAX)

}

void abort_io(const char *func, const char *filename) {
	LOG(ERROR, "Fatal %s(%s): %s", func, filename, strerror(errno));
	abort();
}

(-)a/management/univention-directory-listener/src/cache_lowlevel.h (-1 lines)

Lines 37-43	Link Here

int unparse_entry(void **data, u_int32_t *size, CacheEntry *entry);

int unparse_entry(void **data, u_int32_t *size, CacheEntry *entry);

int parse_entry(void *data, u_int32_t size, CacheEntry *entry);

int parse_entry(void *data, u_int32_t size, CacheEntry *entry);

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

void abort_io(const char *func, const char *filename) __attribute__((noreturn));

void abort_io(const char *func, const char *filename) __attribute__((noreturn));

#endif /* _CACHE_LOWLEVEL_ */

#endif /* _CACHE_LOWLEVEL_ */




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

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

#include "common.h"

	int i;
	bool abort_init = false;

	LOG(WARN, "initializing module %s", handler->name);

	memset(&old_cache_entry, 0, sizeof(CacheEntry));
	LOG(INFO, "call handler_clean for module %s", handler->name);
	handler_clean(handler);
	LOG(INFO, "call handler_initialize for module %s", handler->name);
	handler_initialize(handler);

	/* remove old entries for module */
	LOG(INFO, "remove old entries for module %s", handler->name);
	for (rv = cache_first_entry(&id2entry_cursor_p, &id2dn_cursor_p, &dn, &cache_entry); rv != MDB_NOTFOUND; rv = cache_next_entry(&id2entry_cursor_p, &id2dn_cursor_p, &dn, &cache_entry)) {
		if (rv == -1)
			continue;

		cache_free_entry(&dn, &cache_entry);
	}

	LOG(INFO, "call cache_free_cursor for module %s", handler->name);
	cache_free_cursor(id2entry_cursor_p, id2dn_cursor_p);

	LOG(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) {
		LOG(WARN, "error while reading from database");
		return LDAP_OTHER;
	} else if (rv == 0) {
		signals_block();

		cache_free_entry(NULL, &cache_entry);
	}

	LOG(INFO, "module %s for relating objects", handler->name);
	rv = LDAP_SUCCESS;
	for (f = handler->filters; !abort_init && f != NULL && *f != NULL; f++) {
		/* When initializing a module, only search for the DNs. If the

		int sizelimit0 = 0;
		rv = LDAP_RETRY(lp, ldap_search_ext_s(lp->ld, (*f)->base, (*f)->scope, (*f)->filter, _attrs, attrsonly1, serverctrls, clientctrls, &timeout, sizelimit0, &res));
		if (rv != LDAP_SUCCESS) {
			LOG(ERROR, "could not get DNs when initializing %s: %s", handler->name, ldap_err2string(rv));
			return rv;
		}


		}

		if (!(dns = malloc(dn_count * sizeof(struct dn_list)))) {
			LOG(ERROR, "malloc failed");
			abort();  // FIXME
		}


		}

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

			if ((rv = cache_get_entry_lower_upper(dns[i].dn, &cache_entry)) == MDB_NOTFOUND) { /* XXX */
				LDAPMessage *res2, *first;

					cache_new_entry_from_ldap(NULL, &cache_entry, lp->ld, first);
					ldap_msgfree(res2);
				} else if (rv != LDAP_NO_SUCH_OBJECT) {
					LOG(ERROR, "could not get DN %s for handler %s: %s", dns[i].dn, handler->name, ldap_err2string(rv));
					cache_free_entry(NULL, &cache_entry);
					abort_init = true;
					goto cleanup;

				   deleted after we do the ldapsearch. We
				   shouldn't need to care here. */
			} else if (rv != 0) {
				LOG(WARN, "error while reading from database");
				rv = LDAP_OTHER;
				abort_init = true;
				goto cleanup;

		free(dns);
	}
	cache_free_entry(NULL, &old_cache_entry);
	LOG(WARN, "finished initializing module %s with rv=%d", handler->name, rv);
	return rv;
}


	memset(&old_cache_entry, 0, sizeof(CacheEntry));

	if ((rv = cache_new_entry_from_ldap(&dn, &cache_entry, lp->ld, ldap_entry)) != 0) {
		LOG(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) {
		LOG(WARN, "error while reading from database");
		rv = LDAP_OTHER;
	} else {
		signals_block();
		handlers_update(dn, &cache_entry, &old_cache_entry, command);
		if ((rv = cache_update_entry_lower(id, dn, &cache_entry)) != 0) {
			LOG(WARN, "error while writing to database");
		}
		rv = 0;
		signals_unblock();


	rv = handlers_delete(trans->cur.notify.dn, &trans->cur.cache, 'd');
	if (rv == 0)
		LOG(INFO, "deleted from cache: %s", trans->cur.notify.dn);
	if (cache_entry_valid(&trans->cur.cache)) {
		if (rv != 0)
			LOG(WARN, "at least one delete handler failed");
		cache_delete_entry_lower_upper(trans->cur.notify.id, trans->cur.notify.dn);
		cache_free_entry(NULL, &trans->cur.cache);
	} else {
		if (rv != 0)
			LOG(INFO, "not in cache: %s", trans->cur.notify.dn);
	}

	signals_unblock();

	free(server_role);

	if ((notifier_get_schema_id_s(NULL, &new_id)) != 0) {
		LOG(ERROR, "failed to get schema DN");
		return LDAP_OTHER;
	}


		rv = LDAP_RETRY(lp, ldap_search_ext_s(lp->ld, "cn=Subschema", LDAP_SCOPE_BASE, "(objectClass=*)", attrs, attrsonly0, serverctrls, clientctrls, &timeout, sizelimit0, &res));
		if (rv == LDAP_SUCCESS) {
			if ((cur = ldap_first_entry(lp->ld, res)) == NULL) {
				LOG(ERROR, "got no entry for schema");
				return LDAP_OTHER;
			} else {
				rv = change_update_entry(lp, new_id, cur, 'n');
			}
			ldap_memfree(res);
		} else {
			LOG(ERROR, "could not receive schema (%s)", ldap_err2string(rv));
		}
		cache_master_entry.schema_id = new_id;
		rv = cache_update_master_entry(&cache_master_entry);
		if (cache_set_schema_id(new_id))
			LOG(WARN, "failed to write schema ID");
	}

	return rv;

		} else if (!strcasecmp(name, "dc")) {
			cache_entry_add1(&cache_entry, "objectClass", "domain");
		} else {
			LOG(ERROR, "unknown container: %s", name);
			goto out;
		}
		free(name);


	// 5. Store cache entry at intermediate location
	if ((rv = cache_update_entry_lower(trans->cur.notify.id, dn, &cache_entry)) != 0)
		LOG(WARN, "error while writing to database");

out:
	free(name);

		return LDAP_SUCCESS;

	if (same_dn(dn, trans->lp_local->base)) {
		LOG(INFO, "Ignore parent_dn check because dn is ldap base.");
		return LDAP_SUCCESS;
	}


		return rv;

	if (same_dn(parent_dn, trans->lp_local->base)) {
		// LOG(INFO, "parent of DN: %s is base", dn);
		goto out;
	}


	};
	int sizelimit0 = 0;

	LOG(INFO, "checking parent_dn of %s in local LDAP", dn);

	/* try to open a connection to the local LDAP for the parent DN check */
	if (trans->lp_local->ld == NULL) {
		rv = univention_ldap_open(trans->lp_local);
		if (rv != LDAP_SUCCESS) {
			LOG(ERROR, "bind to local LDAP failed");
			goto out;
		}
	}

			/* lookup parent_dn object in remote LDAP */
			rv = LDAP_RETRY(trans->lp, ldap_search_ext_s(trans->lp->ld, parent_dn, LDAP_SCOPE_BASE, filter, attrs, attrsonly0, serverctrls, clientctrls, &timeout, sizelimit0, &res));
			if (rv == LDAP_NO_SUCH_OBJECT) {
				LOG(ERROR, "could not find parent container of dn: %s from %s (%s)", dn, trans->lp->host, ldap_err2string(rv));
				if (is_move(trans))
					rv = fake_container(trans, parent_dn);
			} else { /* parent_dn found in remote LDAP */

					/* entry exists (since we didn't get NO_SUCH_OBJECT),
					 * but was probably excluded through ACLs which makes it
					 * non-existent for us */
					LOG(ERROR, "could not get parent object of dn: %s from %s (%s)", dn, trans->lp->host, ldap_err2string(rv));
					if (is_move(trans))
						rv = fake_container(trans, parent_dn);
					else
						rv = LDAP_INSUFFICIENT_ACCESS;
				} else { /* found data for parent_dn in remote LDAP */
					LOG(PROCESS, "change_update_entry for parent_dn: %s", parent_dn);
					rv = change_update_entry(trans->lp, trans->cur.notify.id, cur, 'n'); /* add parent_dn object */
				}
			}

	rv = check_parent_dn(trans, current_dn);
	signals_block();
	if (same_dn(trans->prev.notify.dn, current_dn))
		LOG(PROCESS, "move_same_dn(%s)", current_dn);
	rv = handlers_delete(trans->prev.notify.dn, &trans->prev.cache, 'r');
	rv = handlers_update(current_dn, &trans->cur.cache, &dummy, 'a');
	signals_unblock();

	// 5. Store cache entry at new location
	if ((rv = cache_update_entry_lower(trans->cur.notify.id, current_dn, &trans->cur.cache)) != 0) {
		LOG(WARN, "error while writing to database");
	}

	// 6. Check for final destination
	if (final) {
		LOG(ALL, "Object finally moved to '%s'", current_dn);
		rv = change_update_entry(trans->lp, trans->cur.notify.id, trans->ldap, 'm');
	}



	trans->cur.ldap_dn = ldap_get_dn(trans->lp->ld, trans->ldap);
	if (!trans->cur.ldap_dn) {
		LOG(ERROR, "failed to get current DN %s", trans->cur.notify.dn);
		goto out;
	}

	switch (trans->cur.notify.command) {
	case 'm':  // modify
		if (!same_dn(trans->cur.notify.dn, trans->cur.ldap_dn)) {
			LOG(PROCESS, "Delaying update for '%s' until moved to '%s'", trans->cur.notify.dn, trans->cur.ldap_dn);
		} else {
			rv = check_parent_dn(trans, trans->cur.ldap_dn);
			rv = change_update_entry(trans->lp, trans->cur.notify.id, trans->ldap, trans->cur.notify.command);

			rv = process_move(trans);
		} else {  // add
			if (!same_dn(trans->cur.notify.dn, trans->cur.ldap_dn))
				LOG(WARN, "Schizophrenia: a NEW object '%s' is added, which ALREADY is in our cache for '%s'?",
				    trans->cur.ldap_dn, trans->cur.notify.dn);
			rv = check_parent_dn(trans, trans->cur.ldap_dn);
			rv = change_update_entry(trans->lp, trans->cur.notify.id, trans->ldap, trans->cur.notify.command);
		}
		break;
	case 'd':  // delete
		if (!same_dn(trans->cur.notify.dn, trans->cur.ldap_dn))
			LOG(WARN, "Resurrection: DELETED object '%s' will re-appear at '%s'?", trans->cur.notify.dn, trans->cur.ldap_dn);
		change_delete(trans);
		rv = 0;
		break;

		rv = 0;
		break;
	default:
		LOG(ERROR, "Unknown command: %c", trans->cur.notify.command);
	}

out:

	int rv;
	const char *uuid = NULL;

	LOG(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) {
		LOG(WARN, "error reading database for %s", trans->cur.notify.dn);
		return LDAP_OTHER;
	}
	switch (trans->prev.notify.command) {

		break;
	case 'r':  // move_from ... move_to
		if (!cache_entry_valid(&trans->prev.cache)) {
			LOG(ERROR, "move_to without history '%s'", trans->prev.notify.dn);
			break;
		}
		if (rv == 0) {
			LOG(INFO, "move_to collision at '%s'", trans->cur.notify.dn);
			cache_free_entry(NULL, &trans->cur.cache);
		}
		if (is_move(trans)) {

			break;
		}
	default:
		LOG(ERROR, "non consecutive move: %ld:%c:%s << %ld:%c:%s", trans->prev.notify.id, trans->prev.notify.command, trans->prev.notify.dn, trans->cur.notify.id, trans->cur.notify.command, trans->cur.notify.dn);
		                 trans->cur.notify.command, trans->cur.notify.dn);
		rv = 1;
		goto out;
	}

	if (uuid) {
		LOG(ALL, "updating by UUID %s", uuid);
		base = trans->lp->base;
		scope = LDAP_SCOPE_SUBTREE;
		snprintf(filter, sizeof(filter), "(entryUUID=%s)", uuid);
		trans->cur.uuid = strdup(uuid);
	} else {
	retry_dn:
		LOG(ALL, "updating by DN %s", trans->cur.notify.dn);
		base = trans->cur.notify.dn;
		scope = LDAP_SCOPE_BASE;
		snprintf(filter, sizeof(filter), "(objectClass=*)");

		}
		trans->ldap = NULL;
	} else {
		LOG(WARN, "error searching DN %s: %d", trans->cur.notify.dn, rv);
		_free_transaction_op(&trans->cur);
	}
	ldap_msgfree(res);




#include <pwd.h>
#include <sys/types.h>

#include <univention/debug.h>

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

		abort();

	if (access(cache_mdb_filename, F_OK) != -1) {
		LOG(ERROR, "%s already exists", cache_mdb_filename);
		exit(EXIT_FAILURE);
	}
}


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

(-)a/management/univention-directory-listener/src/demo.c (-2 lines)

Lines 35-42	Link Here

#include <unistd.h>

#include <unistd.h>

#include <string.h>

#include <string.h>

#include <univention/debug.h>

#include "network.h"

#include "network.h"

#include "common.h"

#include "common.h"

(-)a/management/univention-directory-listener/src/dump.c (-3 / +1 lines)

Lines 40-47	Link Here

#include <pwd.h>

#include <pwd.h>

#include <sys/types.h>

#include <sys/types.h>

#include <univention/debug.h>

#include "cache.h"

#include "cache.h"

#include "common.h"

#include "common.h"

Lines 120-126 int main(int argc, char *argv[]) {	Link Here

120

		fp = stdout;

118

		fp = stdout;

121

119

122

	if (fp == NULL) {

120

	if (fp == NULL) {

123

		univention_debug(UV_DEBUG_LISTENER, UV_DEBUG_ERROR, "Couldn't open dump file");

121

		LOG(ERROR, "Couldn't open dump file");

124

		exit(1);

122

		exit(1);

125

123

126

	rv = snprintf(cache_mdb_dir, PATH_MAX, "%s/cache", cache_dir);

124

	rv = snprintf(cache_mdb_dir, PATH_MAX, "%s/cache", cache_dir);




#include <python2.7/compile.h>
#include <python2.7/marshal.h>
#include <python2.7/node.h>
#include <univention/debug.h>

#include "cache_lowlevel.h"
#include "base64.h"


	if ((fp = fopen(filename, "r")) == NULL)
		return NULL;
	LOG(ALL, "Load file %s", filename);

	namep = strrchr(filename, '.');
	if ((namep != NULL) && (strcmp(namep, ".pyo") == 0)) {

	} else {
		node *n;

		LOG(ALL, "Parse file %s", filename);
		if ((n = PyParser_SimpleParseFile(fp, filename, Py_file_input)) == NULL) {
			LOG(ALL, "Parse failed %s", filename);
			return NULL;
		}
		LOG(ALL, "pyNode compile %s", filename);
		co = PyNode_Compile(n, filename);
		PyNode_Free(n);
	}

		return NULL;
	}

	LOG(ALL, "execCodeModuleEx %s", filename);
	m = PyImport_ExecCodeModuleEx(name, (PyObject *)co, filename);
	free(name);
	LOG(ALL, "Module done %s", filename);

	return m;
}

	Handler *handler;
	int rv;

	LOG(INFO, "importing handler %s", filename);

	if ((handler = malloc(sizeof(Handler))) == NULL)
		return 1;
	memset(handler, 0, sizeof(Handler));

	if ((handler->module = module_import(filename)) == NULL) {
		LOG(ERROR, "import of filename=%s failed", filename);
		error_msg = "module_import()";
		goto error;
	}

	} else {
		rv = fscanf(state_fp, "%u", &handler->state);
		if (rv != 1)
			LOG(WARN, "Failed reading %s: %s", state_filename, strerror(errno));
		fclose(state_fp);
	}


	free(handler->modrdn);
	free(handler->name);
	free(handler);
	LOG(ERROR, "import of filename=%s failed in %s", filename, error_msg ? error_msg : "???");
	return 1;
}



/* run postrun handler */
static int handler_postrun(Handler *handler) {
	LOG(INFO, "%s (prepared=%d)", handler->name, handler->prepared);
	if (!handler->prepared)
		return 0;
	if (handler->postrun) {


	if ((handler->state & HANDLER_READY) != HANDLER_READY) {
		if (INIT_ONLY) {
			LOG(WARN, "%s (not ready) (ignore)", handler->name);
		} else {
			LOG(WARN, "%s (not ready)", handler->name);
			return 1;
		}
	}

		abort();
	state_fp = fopen(state_filename, "w");
	if (state_fp == NULL) {
		LOG(ERROR, "could not open %s", state_filename);
	} else {
		fprintf(state_fp, "%d", handler->state);
		rv = fclose(state_fp);

	char **cur;

	for (cur = changes; cur != NULL && *cur != NULL; cur++) {
		LOG(ALL, "%s ? %s", *cur, attribute);
		if (strcmp(*cur, attribute) == 0)
			return 1;
	}

	int matched;
	int rv = 0;

	LOG(ALL, "%s considered", handler->name);

	/* check if attributes for handler have changed



	up_to_date:
		if (uptodate) {
			LOG(INFO, "%s (up-to-date)", handler->name);
			cache_entry_module_add(new, handler->name);
			return 0;
		}

	/* check if the handler's search filter matches */
	matched = cache_entry_ldap_filter_match(handler->filters, dn, new);
	if (!matched) {
		LOG(ALL, "%s (filter doesn't match)", handler->name);
		return 0;
	}

	/* run handler */
	if (handler_exec(handler, dn, new, old, command) == 0) {
		cache_entry_module_add(new, handler->name);
		LOG(INFO, "%s (successful)", handler->name);
	} else {
		LOG(WARN, "%s (failed)", handler->name);
		rv = 1;
	}


	char **changes;
	int rv = 0;

	LOG(INFO, "running handlers for %s", dn);

	changes = cache_entry_changed_attributes(new, old);


	char **changes;
	int rv = 0;

	LOG(INFO, "running handlers [%s] for %s", handler->name, dn);

	changes = cache_entry_changed_attributes(new, old);


	Handler *handler;
	int rv = 0;

	LOG(INFO, "delete handlers for %s", dn);

	for (handler = handlers; handler != NULL; handler = handler->next) {
		/* run the replication handler in any case, see Bug #29475 */
		if (!cache_entry_module_present(old, handler->name) && strcmp(handler->name, "replication")) {
			LOG(INFO, "%s (skipped)", handler->name);
			continue;
		}
		if (handler_exec(handler, dn, NULL, old, command) == 0) {
			LOG(INFO, "%s (successful)", handler->name);
			cache_entry_module_remove(old, handler->name);
		} else {
			LOG(INFO, "%s (failed)", handler->name);
			rv = 1;
		}
	}

	PyObject *argtuple;
	__attribute__((unused)) int rv = 1;

	LOG(INFO, "setting data for all handlers: key=%s  value=%s", key, strcmp("bindpw", key) ? value : "<HIDDEN>");

	/* make argument list */
	if ((argtuple = PyTuple_New(2)) == NULL)

	PyTuple_SetItem(argtuple, 0, PyString_FromString(key));
	PyTuple_SetItem(argtuple, 1, PyString_FromString(value));

	LOG(ALL, "handlers=%p", handlers);
	if (handlers == NULL)
		return 0;

	for (handler = handlers; handler != NULL; handler = handler->next) {
		LOG(ALL, "handler=%p", handler);
		if (handler_set_data(handler, argtuple) < 0)
			rv = -1;
	}




#include <pwd.h>
#include <sys/types.h>

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


	fd = open(pidfile, O_WRONLY | O_CREAT | O_EXCL, 0644);
	if (fd < 0) {
		if (errno == EEXIST)
			LOG(ERROR, "pidfile %s exists, aborting...%d %s", pidfile, errno, strerror(errno));
		else
			LOG(ERROR, "Can not create pidfile %s: %s, aborting...", pidfile, strerror(errno));
		exit(EXIT_FAILURE);
	}


			abort();
		rv = write(fd, buf, rv);
		if (rv)
			LOG(WARN, "Failed to write %s: %s", pidfile, strerror(errno));
	}
	rv = close(fd);
	if (rv)
		LOG(WARN, "Failed to close %s: %s", pidfile, strerror(errno));

	// Set new file permissions
	umask(0);

	// Change the working directory to the root directory
	rv = chdir("/");
	if (rv)
		LOG(WARN, "Failed to change directory: %s", strerror(errno));

	if ((null = open("/dev/null", O_RDWR)) == -1) {
		LOG(ERROR, "could not open /dev/null: %s", strerror(errno));
		exit(EXIT_FAILURE);
	}
	dup2(null, STDIN_FILENO);

		dup2(log, STDERR_FILENO);
		rv = close(log);
		if (rv)
			LOG(WARN, "Failed to close /var/log/univention/listener.log: %s", strerror(errno));
	} else {
		dup2(null, STDERR_FILENO);
	}
	rv = close(null);
	if (rv)
		LOG(WARN, "Failed to close /dev/null: %s", strerror(errno));

	// Close all open file descriptors
	for (fd = sysconf(_SC_OPEN_MAX); fd > STDERR_FILENO; fd--)

		return;

	if ((listener_user = getpwnam("listener")) == NULL) {
		LOG(ERROR, "failed to get passwd entry for listener");
		exit(1);
	}

	if (setegid(listener_user->pw_gid) != 0) {
		LOG(ERROR, "failed to change to listener gid");
		exit(1);
	}
	if (seteuid(listener_user->pw_uid) != 0) {
		LOG(ERROR, "failed to change to listener uid");
		exit(1);
	}
}

	char dirname[PATH_MAX];
	int rv;

	LOG(INFO, "purging cache");
	if ((dir = opendir(cache_dir)) != NULL) {
		while ((dirent = readdir(dir))) {
			char path[PATH_MAX];

	int sizelimit0 = 0;

	if (univention_ldap_open(lp) != LDAP_SUCCESS) {
		LOG(WARN, "can not connect to LDAP server %s:%d", lp->host, lp->port);
		goto fail;
	}
	if (notifier_client_new(NULL, lp->host, 1) != 0)

	case LDAP_SUCCESS:
		return 0;
	case LDAP_NO_SUCH_OBJECT:
		LOG(ERROR, "Failed to find \"(objectClass=univentionBase)\" on LDAP server %s:%d", lp->host, lp->port);
		break;
	default:
		LOG(ERROR, "Failed to search for \"(objectClass=univentionBase)\" on LDAP "
		           "server %s:%d with message %s",
		    lp->host, lp->port, ldap_err2string(rc));
		break;
	}
fail:

	}

	univention_debug_set_level(UV_DEBUG_LISTENER, debugging);
	univention_debug_set_level(UV_DEBUG_TRANSFILE, debugging);
	univention_debug_set_level(UV_DEBUG_LDAP, debugging);

	{

		if (rv < 0 || rv >= PATH_MAX)
			abort();
		if (stat(filename, &stbuf) == 0) {
			LOG(ERROR, "Corrupt cache");
			exit(3);
		}
	}

	/* choose server to connect to */
	if (lp->host == NULL && lp->uri == NULL) {
		select_server(lp);
		LOG(INFO, "no server given, choosing one by myself (%s)", lp->host);
	}

	while (do_connection(lp) != 0) {
		if (suspend_connect()) {
			if (initialize_only) {
				LOG(ERROR, "can not connect any server, exit");
				exit(1);
			}
			LOG(WARN, "can not connect any server, retrying in 30 seconds");
			sleep(30);
		}

		select_server(lp);
		LOG(WARN, "chosen server: %s:%d", lp->host, lp->port);
	}

	LOG(INFO, "connection okay to host %s:%d", lp->host, lp->port);

	/* connect to local LDAP server */
	server_role = univention_config_get_string("server/role");

		handlers_set_data_all("ldapserver", lp->host);

	if (notifier_get_id_s(NULL, &id) != 0) {
		LOG(ERROR, "failed to receive current ID");
		return 1;
	}


		if (cache_master_entry.id == -1) {
			rv = notifier_get_id_s(NULL, &cache_master_entry.id);
			if (rv != 0) {
				LOG(ERROR, "failed to receive current ID");
				return 1;
			}
		}

		return rv;
	/* Legacy file for Nagios et al. */
	if (cache_set_int("notifier_id", cache_master_entry.id))
		LOG(WARN, "failed to write notifier ID");

	/* update schema */
	if ((rv = change_update_schema(lp)) != LDAP_SUCCESS)


	/* do initial import of entries */
	if ((rv = change_new_modules(lp)) != LDAP_SUCCESS) {
		LOG(ERROR, "change_new_modules: %s", ldap_err2string(rv));
		return rv;
	}
	signals_unblock();

	}

	if (rv != 0)
		LOG(ERROR, "listener: %d", rv);

	univention_ldap_close(lp);
	univention_ldap_close(lp_local);




#include <sys/stat.h>
#include <errno.h>

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

#include "common.h"


/* Send buffer in blocking mode. */
static int send_block(NotifierClient *client, const char *buf, size_t len) {
	LOG(ALL, ">>>%s", buf);
	return write(client->fd, buf, len);
}


	while (result == NULL || (pos = strstr(result, "\n\n")) == NULL) {
		ssize_t r;

		LOG(ALL, "RESULT: [%s]", result);
		if ((rv = notifier_wait(client, timeout)) == 0) {
			LOG(ERROR, "timeout when receiving data");
			return 0;
		} else if (rv < 0)
			return 0;

		r = read(client->fd, buf, BUFSIZ);
		if (r == 0) {
			LOG(ERROR, "connection to notifier was closed");
			return 0;
		} else if (r < 0) {
			LOG(ERROR, "error %d: %s while receiving from notifier", errno, strerror(errno));
			return 0;
		}


		client->buf = NULL;
	}

	LOG(ALL, "<<<%s", *back);
	return strlen(*back);
}


	assert(client->fd > -1);

	if ((rv = notifier_wait(client, timeout)) == 0) {
		LOG(WARN, "no data is available (i.e. timeout elapsed)");
		return 0;
	} else if (rv < 0)
		return 0;

		client = &global_client;

	if (starttls >= 2) {
		LOG(ERROR, "This version does not support TLS");
		return 1;
	}


	address6.sin6_family = AF_INET6;
	address6.sin6_port = htons(NOTIFIER_PORT_PROTOCOL2);

	LOG(INFO, "connecting to notifier %s:%d", client->server, NOTIFIER_PORT_PROTOCOL2);

	err = getaddrinfo(client->server, NULL, &hints, &result_addrinfo);
	if (err != 0) {
		LOG(WARN, "address resolution of %s failed with errorcode %d: %s", client->server, err, gai_strerror(err));
		free(client->server);
		client->server = NULL;
		return 1;

		switch (res->ai_family) {
		case AF_INET:
			if ((client->fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
				LOG(WARN, "creating IPv4 socket descriptor failed with errorcode %d: %s", errno, strerror(errno));
				continue;
			}
			memcpy(&address4.sin_addr, &((struct sockaddr_in *)res->ai_addr)->sin_addr, sizeof(address4.sin_addr));


		case AF_INET6:
			if ((client->fd = socket(AF_INET6, SOCK_STREAM, 0)) == -1) {
				LOG(WARN, "creating IPv6 socket descriptor failed with errorcode %d: %s", errno, strerror(errno));
				continue;
			}
			memcpy(&address6.sin6_addr, &((struct sockaddr_in6 *)res->ai_addr)->sin6_addr, sizeof(address6.sin6_addr));

			int ret;
			ret = setsockopt(client->fd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
			if (ret < 0)
				LOG(WARN, "Failed to set SO_RCVTIMEO");
			ret = setsockopt(client->fd, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout));
			if (ret < 0)
				LOG(WARN, "Failed to set SO_SNDTIMEO");

			const int enable = 1;
			ret = setsockopt(client->fd, SOL_SOCKET, SO_KEEPALIVE, &enable, sizeof(enable));
			if (ret < 0)
				LOG(WARN, "Failed to enable TCP KEEPALIVE");
			const int idle = 60;
			ret = setsockopt(client->fd, SOL_TCP, TCP_KEEPIDLE, &idle, sizeof(idle));
			if (ret < 0)
				LOG(WARN, "Failed to set TCP_KEEPIDLE");
			const int probes = 12;
			ret = setsockopt(client->fd, SOL_TCP, TCP_KEEPCNT, &probes, sizeof(probes));
			if (ret < 0)
				LOG(WARN, "Failed to set TCP_KEEPCNT");
			const int interval = 5;
			ret = setsockopt(client->fd, SOL_TCP, TCP_KEEPINTVL, &interval, sizeof(interval));
			if (ret < 0)
				LOG(WARN, "Failed to set TCP_KEEPINTVL");
		}

		if (connect(client->fd, address, addrlen) == -1) {
			LOG(INFO, "connection to %s failed with errorcode %d: %s", addrstr, errno, strerror(errno));
			close(client->fd);
			client->fd = -1;
			continue;

	freeaddrinfo(result_addrinfo);

	if (client->fd == -1) {
		LOG(ERROR, "failed to connect to any notifier");
		free(client->server);
		client->server = NULL;
		return 2;
	}

	LOG(INFO, "established connection to %s port %d", addrstr, NOTIFIER_PORT_PROTOCOL2);

	const char *header = "Version: 2\nCapabilities: \n\n";
	const size_t len = strlen(header);
	char *result, *tok;

	if (send_block(client, header, len) != len) {
		LOG(ERROR, "couldn't send header");
		free(client->server);
		client->server = NULL;
		return 1;
	}
	if (recv_block(client, &result, NOTIFIER_TIMEOUT) < 1) {
		LOG(ERROR, "couldn't receive header");
		free(client->server);
		client->server = NULL;
		return 1;

	for (tok = strtok(result, "\n"); tok != NULL; tok = strtok(NULL, "\n")) {
		char *val;
		if ((val = strchr(tok, ':')) == NULL) {
			LOG(ERROR, "ignoring bad header: [%s]", tok);
			continue;
		}
		*val++ = '\0';

	free(result);

	if (client->protocol != 2) {
		LOG(ERROR, "Protocol version %d is not supported", client->protocol);
		free(client->server);
		client->server = NULL;
		return 1;

		}
	} while (rv == -1 && errno == EINTR);
	if (rv == -1) {
		LOG(ERROR, "select: %s", strerror(errno));
	}

	return rv;




#include <sys/time.h>
#include <sys/statvfs.h>

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



static int connect_to_ldap(univention_ldap_parameters_t *lp) {
	while (univention_ldap_open(lp) != LDAP_SUCCESS) {
		LOG(WARN, "can not connect to ldap server (%s)", lp->host);

		if (suspend_connect()) {
			LOG(WARN, "can not connect to any ldap server, retrying in 30 seconds");
			sleep(30);
		}

		select_server(lp);
		LOG(WARN, "chosen server: %s:%d", lp->host, lp->port);
	}

	return LDAP_SUCCESS;

		if (free_mib >= min_mib)
			continue;

		LOG(ERROR, "File system '%s' full: %" PRId64 " < %" PRId64, *dirname, free_mib, min_mib);
		abort();
	}
}


		check_free_space();

		LOG(INFO, "Last Notifier ID: %lu", id);
		if ((msgid = notifier_get_dn(NULL, id + 1)) < 1)
			break;


			if ((rv = notifier_wait(NULL, timeout)) == 0) {
				if (timeout == DELAY_ALIVE) {
					if (notifier_alive_s(NULL) == 1) {
						LOG(ERROR, "failed to get alive answer");
						return 1;
					}
					notifier_resend_get_dn(NULL, msgid, id + 1);

						ldap_unbind_ext(trans.lp_local->ld, NULL, NULL);
						trans.lp_local->ld = NULL;
					}
					LOG(INFO, "running postrun handlers");
					handlers_postrun_all();
					timeout = DELAY_ALIVE;
				}
				continue;
			} else if (rv > 0 && notifier_recv_result(NULL, NOTIFIER_TIMEOUT) == 0) {
				LOG(ERROR, "failed to recv result");
				return 1;
			} else if (rv < 0) {
				return 1;


		memset(&trans.cur, 0, sizeof(trans.cur));
		if (notifier_get_dn_result(NULL, msgid, &trans.cur.notify) != 0) {
			LOG(ERROR, "failed to get dn result");
			return 1;
		}
		LOG(INFO, "notifier returned = id: %ld\tdn: %s\tcmd: %c", trans.cur.notify.id, trans.cur.notify.dn, trans.cur.notify.command);

		if (trans.cur.notify.id != id + 1) {
			LOG(ERROR, "notifier returned transaction id %ld (%ld expected)", trans.cur.notify.id, id + 1);
			rv = 1;
			goto out;
		}

		/* ensure that LDAP connection is open */
		if (trans.lp->ld == NULL) {
			if ((rv = connect_to_ldap(trans.lp)) != 0) {
				LOG(ERROR, "failed to connect to LDAP");
				goto out;
			}
		}

		/* Try to do the change. If the LDAP server is down, try
		   to reconnect */
		while ((rv = change_update_dn(&trans)) != LDAP_SUCCESS) {
			LOG(ERROR, "change_update_dn failed: %d", rv);
			if (rv == LDAP_SERVER_DOWN)
				if ((rv = connect_to_ldap(trans.lp)) == 0)
					continue;

		cache_master_entry.id = id;
		cache_update_master_entry(&cache_master_entry);
		if (cache_set_int("notifier_id", id))
			LOG(WARN, "failed to write notifier ID");
		change_free_transaction_op(&trans.cur);
	}





#include <stdlib.h>
#include <time.h>
#include "select_server.h"
#include "common.h"
#include <univention/ldap.h>
#include <univention/config.h>


				if (!name[0])
					continue;
				server_list[server_list_entries++].server_name = strdup(name);
				LOG(INFO, "Backup found: %s", name);
			}
			if (server_list_entries >= ARRAY_SIZE(server_list))
				LOG(ERROR, "Too many (more than %zd) backup-servers found", ARRAY_SIZE(server_list));
			/* Append notifier on DC Master unless explicitly disabled */
			if (server_list_entries < ARRAY_SIZE(server_list) && !backup_notifier)
				server_list[server_list_entries++].server_name = strdup(ldap_master);

			if (!seed) {
				seed = getpid() * time(NULL);
				srandom(seed);
				LOG(INFO, "rands with seed %ud ", seed);
			}
			int randval = random() % server_list_entries;
			LOG(INFO, "randval = %d ", randval);

			// server_list[randval].conn_attemp++;
			lp->host = strdup(server_list[randval].server_name);

					lp->port = backup_port;
			}
		} else {
			LOG(INFO, "No Backup found, server is ldap/master");
			lp->host = strdup(ldap_master);
			if (ldap_master_port > 0)
				lp->port = ldap_master_port;

	free(ldap_master);
	free(server_role);

	LOG(INFO, "LDAP-Server is %s:%d", lp->host, lp->port);
}




#include <stdio.h>
#include <unistd.h>

#include <univention/debug.h>

#include "handlers.h"
#include "cache.h"
#include "common.h"

void signals_block(void) {
	static int init_done = 0;

	LOG(ALL, "blocking signals (was %d)", sig_block_count);
	if ((++sig_block_count) != 1)
		return;


}

void signals_unblock(void) {
	LOG(ALL, "unblocking signals (was %d)", sig_block_count);
	if ((--sig_block_count) != 0)
		return;
	sigprocmask(SIG_UNBLOCK, &block_mask, NULL);



void sig_usr1_handler(int sig) {
	LOG(WARN, "received signal %d", sig);
	int loglevel = univention_debug_get_level(UV_DEBUG_LISTENER);
	if (loglevel < UV_DEBUG_ALL) {
		loglevel += 1;
		LOG(WARN, "increasing univention_debug_level to %d", loglevel);
		univention_debug_set_level(UV_DEBUG_LISTENER, loglevel);
	}
}

void sig_usr2_handler(int sig) {
	LOG(WARN, "received signal %d", sig);
	int loglevel = univention_debug_get_level(UV_DEBUG_LISTENER);
	if (loglevel > UV_DEBUG_ERROR) {
		loglevel -= 1;
		LOG(WARN, "decreasing univention_debug_level to %d", loglevel);
		univention_debug_set_level(UV_DEBUG_LISTENER, loglevel);
	}
}

	static bool exit_handler_running = false;

	if (exit_handler_running) {
		LOG(WARN, "received another signal %d, ignoring", sig);
		return;
	}
	exit_handler_running = true;

	if (sig)
		LOG(WARN, "received signal %d", sig);

	cache_close();
	unlink(pidfile);

}

void reload_handler(int sig) {
	LOG(WARN, "received signal %d", sig);
	handlers_reload_all_paths();
}





#include <sys/types.h>
#include <sys/stat.h>

#define LOG_CATEGORY UV_DEBUG_TRANSFILE

#include "common.h"
#include "transfile.h"


	snprintf(buf, sizeof(buf), "%s.lock", name);

	if ((*l_file = fopen(buf, "a")) == NULL) {
		LOG(WARN, "Could not open lock file [%s]", buf);
		return NULL;
	}


		int rc = lockf(l_fd, F_TLOCK, 0);
		if (!rc)
			break;
		LOG(INFO, "Could not get lock for file [%s]; count=%d", buf, count);
		count++;
		if (count > listener_lock_count) {
			LOG(ERROR, "Could not get lock for file [%s]; exit", buf);
			exit(0);
		}
		usleep(1000);
	}

	if ((file = fopen(name, type)) == NULL) {
		LOG(WARN, "Could not open file [%s]", name);

		int rc = lockf(l_fd, F_ULOCK, 0);
		if (rc)
			LOG(WARN, "Failed to unlock %s: %s", buf, strerror(errno));
		fclose(*l_file);
		*l_file = NULL;
	}

		int l_fd = fileno(*l_file);
		int rc = lockf(l_fd, F_ULOCK, 0);
		if (rc)
			LOG(ALL, "unlockf(): %d", rc);
		rv |= fclose(*l_file);
		*l_file = NULL;
	}


	if (stat(failed_ldif_file, &stat_buf) != 0)
		return false;
	LOG(ERROR, "'failed.ldif' exists. Check for %s", failed_ldif_file);
	return true;
}


	assert(!notifier_has_failed_ldif());

	if ((file = fopen_lock(transaction_file, "a+", &l_file)) == NULL) {
		LOG(ERROR, "Could not open %s", transaction_file);
		return res;
	}

	LOG(INFO, "write to transaction file dn=[%s], command=[%c]", entry.dn, entry.command);
	fprintf(file, "%ld %s %c\n", entry.id, entry.dn, entry.command);
	res = fclose_lock(&file, &l_file);
	if (res != 0)
		LOG(ERROR, "failed to write to transaction file %s: %d", transaction_file, res);

	return res;
}

(-)a/management/univention-directory-listener/src/verify.c (-3 lines)

Lines 40-47	Link Here

#include <sys/types.h>

#include <sys/types.h>

#include <ldap.h>

#include <ldap.h>

#include <univention/debug.h>

#include "cache.h"

#include "cache.h"

#include "common.h"

#include "common.h"

#include "utils.h"

#include "utils.h"

Return to bug 35707