Adding upstream version 2.6.7+dfsg.upstream/2.6.7+dfsgupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

27 files changed, 9060 insertions, 0 deletions

diff --git a/servers/slapd/back-wt/Makefile.in b/servers/slapd/back-wt/Makefile.in
new file mode 100644
index 0000000..054025e
--- /dev/null
+++ b/servers/slapd/back-wt/Makefile.in
@@ -0,0 +1,54 @@
+# Makefile.in for back-wt
+# $OpenLDAP$
+## This work is part of OpenLDAP Software <http://www.openldap.org/>.
+##
+## Copyright 1998-2022 The OpenLDAP Foundation.
+## All rights reserved.
+##
+## Redistribution and use in source and binary forms, with or without
+## modification, are permitted only as authorized by the OpenLDAP
+## Public License.
+##
+## A copy of this license is available in the file LICENSE in the
+## top-level directory of the distribution or, alternatively, at
+## <http://www.OpenLDAP.org/license.html>.
+
+SRCS = init.c tools.c config.c \
+       add.c bind.c compare.c delete.c modify.c modrdn.c search.c \
+       extended.c operational.c \
+       attr.c index.c key.c filterindex.c \
+       dn2entry.c dn2id.c id2entry.c idl.c \
+       nextid.c ctx.c cache.c
+
+OBJS = init.lo tools.lo config.lo \
+       add.lo bind.lo compare.lo delete.lo modify.lo modrdn.lo search.lo \
+       extended.lo operational.lo \
+       attr.lo index.lo key.lo filterindex.lo \
+       dn2entry.lo dn2id.lo id2entry.lo idl.lo \
+       nextid.lo ctx.lo cache.lo
+
+LDAP_INCDIR= ../../../include
+LDAP_LIBDIR= ../../../libraries
+
+BUILD_OPT = "--enable-wt"
+BUILD_MOD = @BUILD_WT@
+
+mod_DEFS = -DSLAPD_IMPORT
+MOD_DEFS = @WT_CFLAGS@
+MOD_LIBS = @WT_LIBS@
+
+
+shared_LDAP_LIBS = $(LDAP_LIBLDAP_LA) $(LDAP_LIBLBER_LA)
+NT_LINK_LIBS = -L.. -lslapd $(@BUILD_LIBS_DYNAMIC@_LDAP_LIBS)
+UNIX_LINK_LIBS = $(@BUILD_LIBS_DYNAMIC@_LDAP_LIBS)
+
+LIBBASE = back_wt
+
+XINCPATH = -I.. -I$(srcdir)/..
+XDEFS = $(MODULES_CPPFLAGS)
+
+all-local-lib:	../.backend
+
+../.backend: lib$(LIBBASE).a
+	@touch $@
+
diff --git a/servers/slapd/back-wt/add.c b/servers/slapd/back-wt/add.c
new file mode 100644
index 0000000..04c08a1
--- /dev/null
+++ b/servers/slapd/back-wt/add.c
@@ -0,0 +1,373 @@
+/* OpenLDAP WiredTiger backend */
+/* $OpenLDAP$ */
+/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
+ *
+ * Copyright 2002-2022 The OpenLDAP Foundation.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted only as authorized by the OpenLDAP
+ * Public License.
+ *
+ * A copy of this license is available in the file LICENSE in the
+ * top-level directory of the distribution or, alternatively, at
+ * <http://www.OpenLDAP.org/license.html>.
+ */
+/* ACKNOWLEDGEMENTS:
+ * This work was developed by HAMANO Tsukasa <hamano@osstech.co.jp>
+ * based on back-bdb for inclusion in OpenLDAP Software.
+ * WiredTiger is a product of MongoDB Inc.
+ */
+
+#include "portable.h"
+
+#include <stdio.h>
+#include "back-wt.h"
+#include "slap-config.h"
+
+int
+wt_add( Operation *op, SlapReply *rs )
+{
+    struct wt_info *wi = (struct wt_info *) op->o_bd->be_private;
+	struct berval   pdn;
+	char textbuf[SLAP_TEXT_BUFLEN];
+	size_t textlen = sizeof textbuf;
+	AttributeDescription *children = slap_schema.si_ad_children;
+	AttributeDescription *entry = slap_schema.si_ad_entry;
+	ID eid = NOID;
+	LDAPControl **postread_ctrl = NULL;
+	LDAPControl *ctrls[SLAP_MAX_RESPONSE_CONTROLS];
+	int num_ctrls = 0;
+	wt_ctx *wc;
+	Entry *e = NULL;
+	Entry *p = NULL;
+	ID pid = NOID;
+	int rc;
+
+    Debug( LDAP_DEBUG_ARGS, "==> wt_add: %s\n", op->ora_e->e_name.bv_val );
+
+	ctrls[num_ctrls] = 0;
+
+	/* check entry's schema */
+	rs->sr_err = entry_schema_check(
+		op, op->ora_e, NULL,
+		get_relax(op), 1, NULL, &rs->sr_text, textbuf, textlen );
+    if ( rs->sr_err != LDAP_SUCCESS ) {
+        Debug( LDAP_DEBUG_TRACE,
+			   "wt_add: entry failed schema check: %s (%d)\n",
+			   rs->sr_text, rs->sr_err );
+        goto return_results;
+    }
+
+    /* add opattrs to shadow as well, only missing attrs will actually
+     * be added; helps compatibility with older OL versions */
+    rs->sr_err = slap_add_opattrs( op, &rs->sr_text, textbuf, textlen, 1 );
+    if ( rs->sr_err != LDAP_SUCCESS ) {
+        Debug( LDAP_DEBUG_TRACE,
+			   "wt_add: entry failed op attrs add: %s (%d)\n",
+			   rs->sr_text, rs->sr_err );
+        goto return_results;
+    }
+
+    if ( get_assert( op ) &&
+		 ( test_filter( op, op->ora_e, get_assertion( op ))
+		   != LDAP_COMPARE_TRUE ))
+    {
+        rs->sr_err = LDAP_ASSERTION_FAILED;
+        goto return_results;
+    }
+
+	/* Not used
+	 * subentry = is_entry_subentry( op->ora_e );
+	 */
+
+    /*
+     * Get the parent dn and see if the corresponding entry exists.
+     */
+    if ( be_issuffix( op->o_bd, &op->ora_e->e_nname ) ) {
+        pdn = slap_empty_bv;
+    } else {
+        dnParent( &op->ora_e->e_nname, &pdn );
+    }
+
+	wc = wt_ctx_get(op, wi);
+	if( !wc ){
+        Debug( LDAP_DEBUG_ANY, "wt_add: wt_ctx_get failed\n" );
+		rs->sr_err = LDAP_OTHER;
+		rs->sr_text = "internal error";
+        send_ldap_result( op, rs );
+        return rs->sr_err;
+	}
+
+	rc = wt_dn2entry(op->o_bd, wc, &op->o_req_ndn, &e);
+	switch( rc ) {
+	case 0:
+		rs->sr_err = LDAP_ALREADY_EXISTS;
+		goto return_results;
+		break;
+	case WT_NOTFOUND:
+		break;
+	default:
+		/* TODO: retry handling */
+        Debug( LDAP_DEBUG_ANY,
+			   "wt_add: error at wt_dn2entry() rc=%d\n", rc );
+		rs->sr_err = LDAP_OTHER;
+		rs->sr_text = "internal error";
+		goto return_results;
+	}
+
+    /* get parent entry */
+	rc = wt_dn2pentry(op->o_bd, wc, &op->o_req_ndn, &p);
+	switch( rc ){
+	case 0:
+	case WT_NOTFOUND:
+		break;
+	default:
+        Debug( LDAP_DEBUG_ANY,
+			   "wt_add: error at wt_dn2pentry() rc=%d\n", rc );
+		rs->sr_err = LDAP_OTHER;
+		rs->sr_text = "internal error";
+		goto return_results;
+	}
+
+	if ( !p )
+		p = (Entry *)&slap_entry_root;
+
+	if ( !bvmatch( &pdn, &p->e_nname ) ) {
+		rs->sr_matched = ber_strdup_x( p->e_name.bv_val,
+									   op->o_tmpmemctx );
+		if ( p != (Entry *)&slap_entry_root ) {
+			rs->sr_ref = is_entry_referral( p )
+				? get_entry_referrals( op, p )
+				: NULL;
+			wt_entry_return( p );
+		} else {
+			rs->sr_ref = NULL;
+		}
+		p = NULL;
+        Debug( LDAP_DEBUG_TRACE, "wt_add: parent does not exist\n" );
+        rs->sr_err = LDAP_REFERRAL;
+        rs->sr_flags = REP_MATCHED_MUSTBEFREED | REP_REF_MUSTBEFREED;
+        goto return_results;
+	}
+
+	rs->sr_err = access_allowed( op, p,
+								 children, NULL, ACL_WADD, NULL );
+	if ( ! rs->sr_err ) {
+		/*
+		if ( p != (Entry *)&slap_entry_root )
+			wt_entry_return( op, p );
+		*/
+		p = NULL;
+
+		Debug( LDAP_DEBUG_TRACE, "wt_add: no write access to parent\n" );
+		rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
+		rs->sr_text = "no write access to parent";
+		goto return_results;;
+	}
+
+	if ( p != (Entry *)&slap_entry_root ) {
+		if ( is_entry_subentry( p ) ) {
+			wt_entry_return( p );
+			p = NULL;
+			/* parent is a subentry, don't allow add */
+			Debug( LDAP_DEBUG_TRACE, "wt_add: parent is subentry\n" );
+			rs->sr_err = LDAP_OBJECT_CLASS_VIOLATION;
+			rs->sr_text = "parent is a subentry";
+			goto return_results;;
+		}
+
+		if ( is_entry_alias( p ) ) {
+			wt_entry_return( p );
+			p = NULL;
+			/* parent is an alias, don't allow add */
+			Debug( LDAP_DEBUG_TRACE, "wt_add: parent is alias\n" );
+			rs->sr_err = LDAP_ALIAS_PROBLEM;
+			rs->sr_text = "parent is an alias";
+			goto return_results;;
+		}
+
+		if ( is_entry_referral( p ) ) {
+			BerVarray ref = get_entry_referrals( op, p );
+			/* parent is a referral, don't allow add */
+			rs->sr_matched = ber_strdup_x( p->e_name.bv_val,
+										   op->o_tmpmemctx );
+			rs->sr_ref = referral_rewrite( ref, &p->e_name,
+										   &op->o_req_dn, LDAP_SCOPE_DEFAULT );
+			ber_bvarray_free( ref );
+			wt_entry_return( p );
+			p = NULL;
+			Debug( LDAP_DEBUG_TRACE, "wt_add: parent is referral\n" );
+
+			rs->sr_err = LDAP_REFERRAL;
+			rs->sr_flags = REP_MATCHED_MUSTBEFREED | REP_REF_MUSTBEFREED;
+			goto return_results;
+		}
+	}
+
+#if 0
+	if ( subentry ) {
+		/* FIXME: */
+		/* parent must be an administrative point of the required kind */
+	}
+#endif
+
+	/* free parent */
+	if ( p != (Entry *)&slap_entry_root ) {
+		pid = p->e_id;
+		if ( p->e_nname.bv_len ) {
+			struct berval ppdn;
+
+			/* ITS#5326: use parent's DN if differs from provided one */
+			dnParent( &op->ora_e->e_name, &ppdn );
+			if ( !dn_match( &p->e_name, &ppdn ) ) {
+				struct berval rdn;
+				struct berval newdn;
+
+				dnRdn( &op->ora_e->e_name, &rdn );
+
+				build_new_dn( &newdn, &p->e_name, &rdn, NULL );
+				if ( op->ora_e->e_name.bv_val != op->o_req_dn.bv_val )
+					ber_memfree( op->ora_e->e_name.bv_val );
+				op->ora_e->e_name = newdn;
+
+				/* FIXME: should check whether
+                 * dnNormalize(newdn) == e->e_nname ... */
+			}
+		}
+
+		wt_entry_return( p );
+	}
+	p = NULL;
+
+	rs->sr_err = access_allowed( op, op->ora_e,
+								 entry, NULL, ACL_WADD, NULL );
+
+	if ( ! rs->sr_err ) {
+		Debug( LDAP_DEBUG_TRACE, "wt_add: no write access to entry\n" );
+		rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
+		rs->sr_text = "no write access to entry";
+		goto return_results;
+	}
+
+	/*
+	 * Check ACL for attribute write access
+	 */
+	if (!acl_check_modlist(op, op->ora_e, op->ora_modlist)) {
+		Debug( LDAP_DEBUG_TRACE, "wt_add: no write access to attribute\n" );
+		rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
+		rs->sr_text = "no write access to attribute";
+		goto return_results;
+	}
+
+	rc = wc->session->begin_transaction(wc->session, "isolation=read-uncommitted");
+	if( rc ) {
+		Debug( LDAP_DEBUG_TRACE, "wt_add: begin_transaction failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		rs->sr_err = LDAP_OTHER;
+		rs->sr_text = "begin_transaction failed";
+		goto return_results;
+	}
+	Debug( LDAP_DEBUG_TRACE, "wt_add: session id: %p\n", wc->session );
+
+	wt_next_id( op->o_bd, &eid );
+	op->ora_e->e_id = eid;
+
+	rc = wt_dn2id_add( op, wc, pid, op->ora_e );
+	if( rc ){
+		Debug( LDAP_DEBUG_TRACE,
+			   "wt_add: dn2id_add failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		switch( rc ) {
+		case WT_DUPLICATE_KEY:
+			rs->sr_err = LDAP_ALREADY_EXISTS;
+			break;
+		default:
+			rs->sr_err = LDAP_OTHER;
+		}
+		wc->session->rollback_transaction(wc->session, NULL);
+		goto return_results;
+	}
+
+	rc = wt_id2entry_add( op, wc, op->ora_e );
+	if ( rc ) {
+		Debug( LDAP_DEBUG_TRACE,
+			   "wt_add: id2entry_add failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		if ( rc == LDAP_ADMINLIMIT_EXCEEDED ) {
+			rs->sr_err = LDAP_ADMINLIMIT_EXCEEDED;
+			rs->sr_text = "entry is too big";
+		} else {
+			rs->sr_err = LDAP_OTHER;
+			rs->sr_text = "entry store failed";
+		}
+		wc->session->rollback_transaction(wc->session, NULL);
+		goto return_results;
+	}
+
+	/* add indices */
+	rc = wt_index_entry_add( op, wc, op->ora_e );
+	if ( rc ) {
+		Debug(LDAP_DEBUG_TRACE,
+			  "<== wt_add: index add failed: %s (%d)\n",
+			  wiredtiger_strerror(rc), rc );
+		rs->sr_err = LDAP_OTHER;
+		rs->sr_text = "index add failed";
+		wc->session->rollback_transaction(wc->session, NULL);
+		goto return_results;
+	}
+
+	rc = wc->session->commit_transaction(wc->session, NULL);
+	if( rc ) {
+		Debug( LDAP_DEBUG_TRACE,
+			   "<== wt_add: commit_transaction failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		rs->sr_err = LDAP_OTHER;
+		rs->sr_text = "commit_transaction failed";
+		goto return_results;
+	}
+
+	rs->sr_err = LDAP_SUCCESS;
+
+	/* post-read */
+	if( op->o_postread ) {
+		if( postread_ctrl == NULL ) {
+			postread_ctrl = &ctrls[num_ctrls++];
+			ctrls[num_ctrls] = NULL;
+		}
+		if ( slap_read_controls( op, rs, op->ora_e,
+								 &slap_post_read_bv, postread_ctrl ) )
+		{
+			Debug( LDAP_DEBUG_TRACE, "<=- wt_add: post-read failed!\n" );
+			if ( op->o_postread & SLAP_CONTROL_CRITICAL ) {
+				/* FIXME: is it correct to abort
+                 * operation if control fails? */
+				goto return_results;
+			}
+		}
+	}
+
+	Debug(LDAP_DEBUG_TRACE,
+		  "wt_add: added%s id=%08lx dn=\"%s\"\n",
+		  op->o_noop ? " (no-op)" : "",
+		  op->ora_e->e_id, op->ora_e->e_dn );
+
+return_results:
+	send_ldap_result( op, rs );
+
+	slap_graduate_commit_csn( op );
+
+	if( postread_ctrl != NULL && (*postread_ctrl) != NULL ) {
+        slap_sl_free( (*postread_ctrl)->ldctl_value.bv_val, op->o_tmpmemctx );
+        slap_sl_free( *postread_ctrl, op->o_tmpmemctx );
+    }
+    return rs->sr_err;
+}
+
+/*
+ * Local variables:
+ * indent-tabs-mode: t
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */
diff --git a/servers/slapd/back-wt/attr.c b/servers/slapd/back-wt/attr.c
new file mode 100644
index 0000000..70f278c
--- /dev/null
+++ b/servers/slapd/back-wt/attr.c
@@ -0,0 +1,425 @@
+/* OpenLDAP WiredTiger backend */
+/* $OpenLDAP$ */
+/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
+ *
+ * Copyright 2002-2022 The OpenLDAP Foundation.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted only as authorized by the OpenLDAP
+ * Public License.
+ *
+ * A copy of this license is available in the file LICENSE in the
+ * top-level directory of the distribution or, alternatively, at
+ * <http://www.OpenLDAP.org/license.html>.
+ */
+/* ACKNOWLEDGEMENTS:
+ * This work was developed by HAMANO Tsukasa <hamano@osstech.co.jp>
+ * based on back-bdb for inclusion in OpenLDAP Software.
+ * WiredTiger is a product of MongoDB Inc.
+ */
+
+#include "back-wt.h"
+#include "slap-config.h"
+#include "lutil.h"
+
+/* Find the ad, return -1 if not found,
+ * set point for insertion if ins is non-NULL
+ */
+int
+wt_attr_slot( struct wt_info *wi, AttributeDescription *ad, int *ins )
+{
+	unsigned base = 0, cursor = 0;
+	unsigned n = wi->wi_nattrs;
+	int val = 0;
+
+	while ( 0 < n ) {
+		unsigned pivot = n >> 1;
+		cursor = base + pivot;
+
+		val = SLAP_PTRCMP( ad, wi->wi_attrs[cursor]->ai_desc );
+		if ( val < 0 ) {
+			n = pivot;
+		} else if ( val > 0 ) {
+			base = cursor + 1;
+			n -= pivot + 1;
+		} else {
+			return cursor;
+		}
+	}
+	if ( ins ) {
+		if ( val > 0 )
+			++cursor;
+		*ins = cursor;
+	}
+	return -1;
+}
+
+static int
+ainfo_insert( struct wt_info *wi, AttrInfo *a )
+{
+	int x = INT_MAX;
+	int i = wt_attr_slot( wi, a->ai_desc, &x );
+
+	/* Is it a dup? */
+	if ( i >= 0 )
+		return -1;
+
+	wi->wi_attrs = ch_realloc( wi->wi_attrs, ( wi->wi_nattrs+1 ) *
+							   sizeof( AttrInfo * ));
+	if ( x < wi->wi_nattrs )
+		AC_MEMCPY( &wi->wi_attrs[x+1], &wi->wi_attrs[x],
+				   ( wi->wi_nattrs - x ) * sizeof( AttrInfo *));
+	wi->wi_attrs[x] = a;
+	wi->wi_nattrs++;
+	return 0;
+}
+
+AttrInfo *
+wt_attr_mask(
+	struct wt_info	*wi,
+	AttributeDescription *desc )
+{
+	int i = wt_attr_slot( wi, desc, NULL );
+	return i < 0 ? NULL : wi->wi_attrs[i];
+}
+
+int
+wt_attr_index_config(
+	struct wt_info	*wi,
+	const char		*fname,
+	int			lineno,
+	int			argc,
+	char		**argv,
+	struct		config_reply_s *c_reply)
+{
+	int rc = 0;
+	int	i;
+	slap_mask_t mask;
+	char **attrs;
+	char **indexes = NULL;
+
+	attrs = ldap_str2charray( argv[0], "," );
+
+	if( attrs == NULL ) {
+		fprintf( stderr, "%s: line %d: "
+			"no attributes specified: %s\n",
+			fname, lineno, argv[0] );
+		return LDAP_PARAM_ERROR;
+	}
+
+	if ( argc > 1 ) {
+		indexes = ldap_str2charray( argv[1], "," );
+
+		if( indexes == NULL ) {
+			fprintf( stderr, "%s: line %d: "
+				"no indexes specified: %s\n",
+				fname, lineno, argv[1] );
+			rc = LDAP_PARAM_ERROR;
+			goto done;
+		}
+	}
+
+	if( indexes == NULL ) {
+		mask = wi->wi_defaultmask;
+
+	} else {
+		mask = 0;
+
+		for ( i = 0; indexes[i] != NULL; i++ ) {
+			slap_mask_t index;
+
+			rc = slap_str2index( indexes[i], &index );
+
+			if( rc != LDAP_SUCCESS ) {
+				if ( c_reply )
+				{
+					snprintf(c_reply->msg, sizeof(c_reply->msg),
+						"index type \"%s\" undefined", indexes[i] );
+
+					fprintf( stderr, "%s: line %d: %s\n",
+						fname, lineno, c_reply->msg );
+				}
+				rc = LDAP_PARAM_ERROR;
+				goto done;
+			}
+
+			mask |= index;
+		}
+	}
+
+	if( !mask ) {
+		if ( c_reply )
+		{
+			snprintf(c_reply->msg, sizeof(c_reply->msg),
+				"no indexes selected" );
+			fprintf( stderr, "%s: line %d: %s\n",
+				fname, lineno, c_reply->msg );
+		}
+		rc = LDAP_PARAM_ERROR;
+		goto done;
+	}
+
+	for ( i = 0; attrs[i] != NULL; i++ ) {
+		AttrInfo	*a;
+		AttributeDescription *ad;
+		const char *text;
+#ifdef LDAP_COMP_MATCH
+		ComponentReference* cr = NULL;
+		AttrInfo *a_cr = NULL;
+#endif
+
+		if( strcasecmp( attrs[i], "default" ) == 0 ) {
+			wi->wi_defaultmask |= mask;
+			continue;
+		}
+
+#ifdef LDAP_COMP_MATCH
+		if ( is_component_reference( attrs[i] ) ) {
+			rc = extract_component_reference( attrs[i], &cr );
+			if ( rc != LDAP_SUCCESS ) {
+				if ( c_reply )
+				{
+					snprintf(c_reply->msg, sizeof(c_reply->msg),
+						"index component reference\"%s\" undefined",
+						attrs[i] );
+					fprintf( stderr, "%s: line %d: %s\n",
+						fname, lineno, c_reply->msg );
+				}
+				goto done;
+			}
+			cr->cr_indexmask = mask;
+			/*
+			 * After extracting a component reference
+			 * only the name of a attribute will be remaining
+			 */
+		} else {
+			cr = NULL;
+		}
+#endif
+		ad = NULL;
+		rc = slap_str2ad( attrs[i], &ad, &text );
+
+		if( rc != LDAP_SUCCESS ) {
+			if ( c_reply )
+			{
+				snprintf(c_reply->msg, sizeof(c_reply->msg),
+					"index attribute \"%s\" undefined",
+					attrs[i] );
+
+				fprintf( stderr, "%s: line %d: %s\n",
+					fname, lineno, c_reply->msg );
+			}
+fail:
+#ifdef LDAP_COMP_MATCH
+			ch_free( cr );
+#endif
+			goto done;
+		}
+
+		if( ad == slap_schema.si_ad_entryDN || slap_ad_is_binary( ad ) ) {
+			if (c_reply) {
+				snprintf(c_reply->msg, sizeof(c_reply->msg),
+					"index of attribute \"%s\" disallowed", attrs[i] );
+				fprintf( stderr, "%s: line %d: %s\n",
+					fname, lineno, c_reply->msg );
+			}
+			rc = LDAP_UNWILLING_TO_PERFORM;
+			goto fail;
+		}
+
+		if( IS_SLAP_INDEX( mask, SLAP_INDEX_APPROX ) && !(
+			ad->ad_type->sat_approx
+				&& ad->ad_type->sat_approx->smr_indexer
+				&& ad->ad_type->sat_approx->smr_filter ) )
+		{
+			if (c_reply) {
+				snprintf(c_reply->msg, sizeof(c_reply->msg),
+					"approx index of attribute \"%s\" disallowed", attrs[i] );
+				fprintf( stderr, "%s: line %d: %s\n",
+					fname, lineno, c_reply->msg );
+			}
+			rc = LDAP_INAPPROPRIATE_MATCHING;
+			goto fail;
+		}
+
+		if( IS_SLAP_INDEX( mask, SLAP_INDEX_EQUALITY ) && !(
+			ad->ad_type->sat_equality
+				&& ad->ad_type->sat_equality->smr_indexer
+				&& ad->ad_type->sat_equality->smr_filter ) )
+		{
+			if (c_reply) {
+				snprintf(c_reply->msg, sizeof(c_reply->msg),
+					"equality index of attribute \"%s\" disallowed", attrs[i] );
+				fprintf( stderr, "%s: line %d: %s\n",
+					fname, lineno, c_reply->msg );
+			}
+			rc = LDAP_INAPPROPRIATE_MATCHING;
+			goto fail;
+		}
+
+		if( IS_SLAP_INDEX( mask, SLAP_INDEX_SUBSTR ) && !(
+			ad->ad_type->sat_substr
+				&& ad->ad_type->sat_substr->smr_indexer
+				&& ad->ad_type->sat_substr->smr_filter ) )
+		{
+			if (c_reply) {
+				snprintf(c_reply->msg, sizeof(c_reply->msg),
+					"substr index of attribute \"%s\" disallowed", attrs[i] );
+				fprintf( stderr, "%s: line %d: %s\n",
+					fname, lineno, c_reply->msg );
+			}
+			rc = LDAP_INAPPROPRIATE_MATCHING;
+			goto fail;
+		}
+
+		Debug( LDAP_DEBUG_CONFIG, "index %s 0x%04lx\n",
+			ad->ad_cname.bv_val, mask );
+
+		a = (AttrInfo *) ch_malloc( sizeof(AttrInfo) );
+
+#ifdef LDAP_COMP_MATCH
+		a->ai_cr = NULL;
+#endif
+		a->ai_desc = ad;
+
+		if ( wi->wi_flags & WT_IS_OPEN ) {
+			a->ai_indexmask = 0;
+			a->ai_newmask = mask;
+		} else {
+			a->ai_indexmask = mask;
+			a->ai_newmask = 0;
+		}
+
+#ifdef LDAP_COMP_MATCH
+		if ( cr ) {
+			a_cr = wt_attr_mask( wi, ad );
+			if ( a_cr ) {
+				/*
+				 * AttrInfo is already in AVL
+				 * just add the extracted component reference
+				 * in the AttrInfo
+				 */
+				ch_free( a );
+				rc = insert_component_reference( cr, &a_cr->ai_cr );
+				if ( rc != LDAP_SUCCESS) {
+					fprintf( stderr, " error during inserting component reference in %s ", attrs[i]);
+					rc = LDAP_PARAM_ERROR;
+					goto fail;
+				}
+				continue;
+			} else {
+				rc = insert_component_reference( cr, &a->ai_cr );
+				if ( rc != LDAP_SUCCESS) {
+					fprintf( stderr, " error during inserting component reference in %s ", attrs[i]);
+					rc = LDAP_PARAM_ERROR;
+					ch_free( a );
+					goto fail;
+				}
+			}
+		}
+#endif
+		rc = ainfo_insert( wi, a );
+		if( rc ) {
+			if ( wi->wi_flags & WT_IS_OPEN ) {
+				AttrInfo *b = wt_attr_mask( wi, ad );
+				/* If there is already an index defined for this attribute
+				 * it must be replaced. Otherwise we end up with multiple
+				 * olcIndex values for the same attribute */
+				if ( b->ai_indexmask & WT_INDEX_DELETING ) {
+					/* If we were editing this attr, reset it */
+					b->ai_indexmask &= ~WT_INDEX_DELETING;
+					/* If this is leftover from a previous add, commit it */
+					if ( b->ai_newmask )
+						b->ai_indexmask = b->ai_newmask;
+					b->ai_newmask = a->ai_newmask;
+					ch_free( a );
+					rc = 0;
+					continue;
+				}
+			}
+			if (c_reply) {
+				snprintf(c_reply->msg, sizeof(c_reply->msg),
+					"duplicate index definition for attr \"%s\"",
+					attrs[i] );
+				fprintf( stderr, "%s: line %d: %s\n",
+					fname, lineno, c_reply->msg );
+			}
+
+			rc = LDAP_PARAM_ERROR;
+			goto done;
+		}
+	}
+
+done:
+	ldap_charray_free( attrs );
+	if ( indexes != NULL ) ldap_charray_free( indexes );
+
+	return rc;
+}
+
+static int
+wt_attr_index_unparser( void *v1, void *v2 )
+{
+	AttrInfo *ai = v1;
+	BerVarray *bva = v2;
+	struct berval bv;
+	char *ptr;
+
+	slap_index2bvlen( ai->ai_indexmask, &bv );
+	if ( bv.bv_len ) {
+		bv.bv_len += ai->ai_desc->ad_cname.bv_len + 1;
+		ptr = ch_malloc( bv.bv_len+1 );
+		bv.bv_val = lutil_strcopy(ptr,
+								  (const char*)ai->ai_desc->ad_cname.bv_val );
+		*bv.bv_val++ = ' ';
+		slap_index2bv( ai->ai_indexmask, &bv );
+		bv.bv_val = ptr;
+		ber_bvarray_add( bva, &bv );
+	}
+	return 0;
+}
+
+static AttributeDescription addef = { NULL, NULL, BER_BVC("default") };
+static AttrInfo aidef = { &addef };
+
+void
+wt_attr_index_unparse( struct wt_info *wi, BerVarray *bva )
+{
+	int i;
+
+	if ( wi->wi_defaultmask ) {
+		aidef.ai_indexmask = wi->wi_defaultmask;
+		wt_attr_index_unparser( &aidef, bva );
+	}
+	for ( i=0; i<wi->wi_nattrs; i++ )
+		wt_attr_index_unparser( wi->wi_attrs[i], bva );
+}
+
+void
+wt_attr_info_free( AttrInfo *ai )
+{
+#ifdef LDAP_COMP_MATCH
+	free( ai->ai_cr );
+#endif
+	free( ai );
+}
+
+void
+wt_attr_index_destroy( struct wt_info *wi )
+{
+	int i;
+
+	for ( i=0; i<wi->wi_nattrs; i++ )
+		wt_attr_info_free( wi->wi_attrs[i] );
+
+	free( wi->wi_attrs );
+}
+
+/*
+ * Local variables:
+ * indent-tabs-mode: t
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */
diff --git a/servers/slapd/back-wt/back-wt.h b/servers/slapd/back-wt/back-wt.h
new file mode 100644
index 0000000..386dd85
--- /dev/null
+++ b/servers/slapd/back-wt/back-wt.h
@@ -0,0 +1,120 @@
+/* OpenLDAP WiredTiger backend */
+/* $OpenLDAP$ */
+/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
+ *
+ * Copyright 2002-2022 The OpenLDAP Foundation.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted only as authorized by the OpenLDAP
+ * Public License.
+ *
+ * A copy of this license is available in the file LICENSE in the
+ * top-level directory of the distribution or, alternatively, at
+ * <http://www.OpenLDAP.org/license.html>.
+ */
+/* ACKNOWLEDGEMENTS:
+ * This work was developed by HAMANO Tsukasa <hamano@osstech.co.jp>
+ * based on back-bdb for inclusion in OpenLDAP Software.
+ * WiredTiger is a product of MongoDB Inc.
+ */
+
+#ifndef _BACK_WT_H_
+#define _BACK_WT_H_
+
+#include <portable.h>
+
+#include <ac/errno.h>
+#include <sys/stat.h>
+
+#include "slap.h"
+#include "wiredtiger.h"
+
+/* The default search IDL stack cache depth */
+#define DEFAULT_SEARCH_STACK_DEPTH  16
+
+#define WT_CONFIG_MAX 2048
+
+struct wt_info {
+	WT_CONNECTION *wi_conn;
+	WT_CONNECTION *wi_cache;
+	char *wi_home;
+	char *wi_config;
+	ID	wi_lastid;
+
+	slap_mask_t wi_defaultmask;
+	int         wi_nattrs;
+	struct wt_attrinfo **wi_attrs;
+	void *wi_search_stack;
+	int wi_search_stack_depth;
+
+	struct re_s *wi_index_task;
+
+	int wi_flags;
+#define WT_IS_OPEN      0x01
+#define WT_OPEN_INDEX   0x02
+#define WT_DEL_INDEX    0x08
+#define WT_RE_OPEN      0x10
+#define WT_NEED_UPGRADE 0x20
+#define WT_USE_IDLCACHE 0x40
+};
+
+#define WT_TABLE_ID2ENTRY "table:id2entry"
+#define WT_TABLE_DN2ID "table:dn2id"
+
+#define WT_INDEX_DN "index:id2entry:dn"
+#define WT_INDEX_NDN "index:dn2id:ndn"
+#define WT_INDEX_PID "index:dn2id:pid"
+/* Currently, revdn is primary key, the revdn index is obsolete. */
+#define WT_INDEX_REVDN "index:dn2id:revdn"
+
+/* table for cache */
+#define WT_TABLE_IDLCACHE "table:idlcache"
+
+#define ITEMzero(item) (memset((item), 0, sizeof(WT_ITEM)))
+#define ITEM2bv(item,bv) ((bv)->bv_val = (item)->data, \
+						  (bv)->bv_len = (item)->size)
+#define bv2ITEM(bv,item) ((item)->data = (bv)->bv_val, \
+						 (item)->size = (bv)->bv_len )
+
+#define WT_INDEX_CACHE_SIZE 1024
+
+typedef struct {
+	WT_SESSION *session;
+	int is_begin_transaction;
+	WT_CURSOR *dn2id;
+	WT_CURSOR *dn2id_w;
+	WT_CURSOR *dn2id_ndn;
+	WT_CURSOR *dn2entry;
+	WT_CURSOR *id2entry;
+	WT_CURSOR *id2entry_add;
+	WT_CURSOR *id2entry_update;
+	WT_SESSION *idlcache_session;
+	WT_CURSOR *index_pid;
+} wt_ctx;
+
+/* for the cache of attribute information (which are indexed, etc.) */
+typedef struct wt_attrinfo {
+	AttributeDescription *ai_desc; /* attribute description cn;lang-en */
+	slap_mask_t ai_indexmask;   /* how the attr is indexed  */
+	slap_mask_t ai_newmask; /* new settings to replace old mask */
+	#ifdef LDAP_COMP_MATCH
+	ComponentReference* ai_cr; /*component indexing*/
+	#endif
+} AttrInfo;
+
+/* These flags must not clash with SLAP_INDEX flags or ops in slap.h! */
+#define	WT_INDEX_DELETING	0x8000U	/* index is being modified */
+#define	WT_INDEX_UPDATE_OP	0x03	/* performing an index update */
+
+#include "proto-wt.h"
+
+#endif /* _BACK_WT_H_ */
+
+/*
+ * Local variables:
+ * indent-tabs-mode: t
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */
diff --git a/servers/slapd/back-wt/bind.c b/servers/slapd/back-wt/bind.c
new file mode 100644
index 0000000..43abe87
--- /dev/null
+++ b/servers/slapd/back-wt/bind.c
@@ -0,0 +1,150 @@
+/* OpenLDAP WiredTiger backend */
+/* $OpenLDAP$ */
+/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
+ *
+ * Copyright 2002-2022 The OpenLDAP Foundation.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted only as authorized by the OpenLDAP
+ * Public License.
+ *
+ * A copy of this license is available in the file LICENSE in the
+ * top-level directory of the distribution or, alternatively, at
+ * <http://www.OpenLDAP.org/license.html>.
+ */
+/* ACKNOWLEDGEMENTS:
+ * This work was developed by HAMANO Tsukasa <hamano@osstech.co.jp>
+ * based on back-bdb for inclusion in OpenLDAP Software.
+ * WiredTiger is a product of MongoDB Inc.
+ */
+
+#include "portable.h"
+
+#include <stdio.h>
+#include "back-wt.h"
+#include "slap-config.h"
+
+int
+wt_bind( Operation *op, SlapReply *rs )
+{
+    struct wt_info *wi = (struct wt_info *) op->o_bd->be_private;
+	wt_ctx *wc;
+	int rc;
+	Entry *e = NULL;
+	Attribute *a;
+	AttributeDescription *password = slap_schema.si_ad_userPassword;
+
+    Debug( LDAP_DEBUG_ARGS, "==> wt_bind: dn: %s\n",
+		   op->o_req_dn.bv_val );
+
+	/* allow noauth binds */
+	switch ( be_rootdn_bind( op, NULL ) ) {
+	case LDAP_SUCCESS:
+        /* frontend will send result */
+        return rs->sr_err = LDAP_SUCCESS;
+
+    default:
+        /* give the database a chance */
+        /* NOTE: this behavior departs from that of other backends,
+         * since the others, in case of password checking failure
+         * do not give the database a chance.  If an entry with
+         * rootdn's name does not exist in the database the result
+         * will be the same.  See ITS#4962 for discussion. */
+        break;
+	}
+
+	wc = wt_ctx_get(op, wi);
+	if( !wc ){
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_bind: wt_ctx_get failed\n" );
+		rs->sr_err = LDAP_OTHER;
+		rs->sr_text = "internal error";
+        send_ldap_result( op, rs );
+        return rs->sr_err;
+	}
+
+	/* get entry */
+	rc = wt_dn2entry(op->o_bd, wc, &op->o_req_ndn, &e);
+	switch( rc ) {
+	case 0:
+		break;
+	case WT_NOTFOUND:
+		rs->sr_err = LDAP_INVALID_CREDENTIALS;
+		send_ldap_result( op, rs );
+		return rs->sr_err;
+	default:
+		rs->sr_err = LDAP_OTHER;
+		rs->sr_text = "internal error";
+        send_ldap_result( op, rs );
+        return rs->sr_err;
+	}
+
+	ber_dupbv( &op->oq_bind.rb_edn, &e->e_name );
+
+    /* check for deleted */
+	if ( is_entry_subentry( e ) ) {
+        /* entry is an subentry, don't allow bind */
+		Debug( LDAP_DEBUG_TRACE, "entry is subentry\n" );
+		rs->sr_err = LDAP_INVALID_CREDENTIALS;
+		goto done;
+	}
+
+	if ( is_entry_alias( e ) ) {
+        /* entry is an alias, don't allow bind */
+		Debug( LDAP_DEBUG_TRACE, "entry is alias\n" );
+		rs->sr_err = LDAP_INVALID_CREDENTIALS;
+		goto done;
+	}
+
+	if ( is_entry_referral( e ) ) {
+		Debug( LDAP_DEBUG_TRACE, "entry is referral\n" );
+		rs->sr_err = LDAP_INVALID_CREDENTIALS;
+		goto done;
+	}
+
+	switch ( op->oq_bind.rb_method ) {
+	case LDAP_AUTH_SIMPLE:
+		a = attr_find( e->e_attrs, password );
+		if ( a == NULL ) {
+			rs->sr_err = LDAP_INVALID_CREDENTIALS;
+			goto done;
+		}
+
+		if ( slap_passwd_check( op, e, a, &op->oq_bind.rb_cred,
+								&rs->sr_text ) != 0 )
+		{
+            /* failure; stop front end from sending result */
+			rs->sr_err = LDAP_INVALID_CREDENTIALS;
+			goto done;
+		}
+		rs->sr_err = 0;
+		break;
+
+    default:
+		rs->sr_err = LDAP_STRONG_AUTH_NOT_SUPPORTED;
+		rs->sr_text = "authentication method not supported";
+	}
+
+done:
+	/* free entry */
+	if (e) {
+		wt_entry_return(e);
+	}
+	if (rs->sr_err) {
+		send_ldap_result( op, rs );
+        if ( rs->sr_ref ) {
+            ber_bvarray_free( rs->sr_ref );
+			rs->sr_ref = NULL;
+		}
+	}
+	return rs->sr_err;
+}
+
+/*
+ * Local variables:
+ * indent-tabs-mode: t
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */
diff --git a/servers/slapd/back-wt/cache.c b/servers/slapd/back-wt/cache.c
new file mode 100644
index 0000000..ee393a0
--- /dev/null
+++ b/servers/slapd/back-wt/cache.c
@@ -0,0 +1,231 @@
+/* OpenLDAP WiredTiger backend */
+/* $OpenLDAP$ */
+/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
+ *
+ * Copyright 2002-2022 The OpenLDAP Foundation.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted only as authorized by the OpenLDAP
+ * Public License.
+ *
+ * A copy of this license is available in the file LICENSE in the
+ * top-level directory of the distribution or, alternatively, at
+ * <http://www.OpenLDAP.org/license.html>.
+ */
+/* ACKNOWLEDGEMENTS:
+ * This work was developed by HAMANO Tsukasa <hamano@osstech.co.jp>
+ * based on back-bdb for inclusion in OpenLDAP Software.
+ * WiredTiger is a product of MongoDB Inc.
+ */
+
+#include "portable.h"
+
+#include <stdio.h>
+#include <ac/string.h>
+#include "back-wt.h"
+#include "slap-config.h"
+#include "idl.h"
+
+int wt_idlcache_get(wt_ctx *wc, struct berval *ndn, int scope, ID *ids)
+{
+	int rc = 0;
+	WT_ITEM item;
+	WT_SESSION *session = wc->idlcache_session;
+	WT_CURSOR *cursor = NULL;
+
+	Debug( LDAP_DEBUG_TRACE,
+		   "=> wt_idlcache_get(\"%s\", %d)\n",
+		   ndn->bv_val, scope );
+
+	rc = session->open_cursor(session, WT_TABLE_IDLCACHE, NULL,
+							  NULL, &cursor);
+	if(rc){
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_idlcache_get: open_cursor failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		return rc;
+	}
+	cursor->set_key(cursor, ndn->bv_val, (int8_t)scope);
+	rc = cursor->search(cursor);
+	switch( rc ){
+	case 0:
+		break;
+	case WT_NOTFOUND:
+		Debug(LDAP_DEBUG_TRACE, "<= wt_idlcache_get: miss\n" );
+		goto done;
+	default:
+		Debug( LDAP_DEBUG_ANY, "<= wt_idlcache_get: search failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		rc = 0;
+		goto done;
+	}
+	rc = cursor->get_value(cursor, &item);
+	if (rc) {
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_idlcache_get: get_value failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		goto done;
+	}
+	if (item.size == 0) {
+		Debug(LDAP_DEBUG_TRACE, "<= wt_idlcache_get: updating\n");
+		rc = WT_NOTFOUND;
+		goto done;
+	}
+	memcpy(ids, item.data, item.size);
+
+	Debug(LDAP_DEBUG_TRACE,
+		  "<= wt_idlcache_get: hit id=%ld first=%ld last=%ld\n",
+		  (long)ids[0],
+		  (long)WT_IDL_FIRST(ids),
+		  (long)WT_IDL_LAST(ids));
+done:
+	if(cursor) {
+		cursor->close(cursor);
+	}
+	return rc;
+}
+
+int wt_idlcache_set(wt_ctx *wc, struct berval *ndn, int scope, ID *ids)
+{
+	int rc = 0;
+	WT_ITEM item;
+	WT_SESSION *session = wc->idlcache_session;
+	WT_CURSOR *cursor = NULL;
+
+	Debug( LDAP_DEBUG_TRACE,
+		   "=> wt_idlcache_set(\"%s\", %d)\n",
+		   ndn->bv_val, scope );
+
+	item.size = WT_IDL_SIZEOF(ids);
+	item.data = ids;
+
+	rc = session->open_cursor(session, WT_TABLE_IDLCACHE, NULL,
+							  "overwrite=false", &cursor);
+	if(rc){
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_idlcache_set: open_cursor failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		return rc;
+	}
+	cursor->set_key(cursor, ndn->bv_val, (int8_t)scope);
+	cursor->set_value(cursor, &item);
+	rc = cursor->update(cursor);
+	switch( rc ){
+	case 0:
+		break;
+	case WT_NOTFOUND:
+		// updating cache by another thread
+		goto done;
+	default:
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_idlcache_set: update failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		goto done;
+	}
+
+	Debug(LDAP_DEBUG_TRACE,
+		  "<= wt_idlcache_set: set idl size=%ld\n",
+		  (long)ids[0]);
+done:
+	if(cursor) {
+		cursor->close(cursor);
+	}
+	return rc;
+}
+
+int wt_idlcache_begin(wt_ctx *wc, struct berval *ndn, int scope)
+{
+	int rc = 0;
+	WT_ITEM item;
+	WT_SESSION *session = wc->idlcache_session;
+	WT_CURSOR *cursor = NULL;
+
+	Debug( LDAP_DEBUG_TRACE,
+		   "=> wt_idlcache_begin(\"%s\", %d)\n",
+		   ndn->bv_val, scope );
+
+	item.size = 0;
+	item.data = "";
+
+	rc = session->open_cursor(session, WT_TABLE_IDLCACHE, NULL,
+							  "overwrite=true", &cursor);
+	if(rc){
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_idlcache_begin: open_cursor failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		return rc;
+	}
+	cursor->set_key(cursor, ndn->bv_val, (int8_t)scope);
+	cursor->set_value(cursor, &item);
+	rc = cursor->update(cursor);
+	if(rc){
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_idlcache_begin: update failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		goto done;
+	}
+
+	Debug(LDAP_DEBUG_TRACE,
+		  "<= wt_idlcache_begin: set updating\n" );
+
+done:
+	if(cursor) {
+		cursor->close(cursor);
+	}
+	return rc;
+}
+
+int wt_idlcache_clear(Operation *op, wt_ctx *wc, struct berval *ndn)
+{
+	BackendDB *be = op->o_bd;
+	int rc = 0;
+	struct berval pdn = *ndn;
+	WT_SESSION *session = wc->idlcache_session;
+	WT_CURSOR *cursor = NULL;
+	int level = 0;
+
+	Debug( LDAP_DEBUG_TRACE,
+		   "=> wt_idlcache_clear(\"%s\")\n",
+		   ndn->bv_val );
+
+	if (be_issuffix( be, ndn )) {
+		return 0;
+	}
+
+	rc = session->open_cursor(session, WT_TABLE_IDLCACHE, NULL,
+							  NULL, &cursor);
+	if(rc){
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_idlcache_clear: open_cursor failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		return rc;
+	}
+
+	do {
+		dnParent( &pdn, &pdn );
+		if (level == 0) {
+			/* clear only parent level cache */
+			cursor->set_key(cursor, pdn.bv_val, (int8_t)LDAP_SCOPE_ONE);
+			cursor->remove(cursor);
+		}
+		cursor->set_key(cursor, pdn.bv_val, (int8_t)LDAP_SCOPE_SUB);
+		cursor->remove(cursor);
+		cursor->set_key(cursor, pdn.bv_val, (int8_t)LDAP_SCOPE_CHILDREN);
+		cursor->remove(cursor);
+		level++;
+	}while(!be_issuffix( be, &pdn ));
+
+	if(cursor) {
+		cursor->close(cursor);
+	}
+	return 0;
+}
+
+/*
+ * Local variables:
+ * indent-tabs-mode: t
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */
diff --git a/servers/slapd/back-wt/compare.c b/servers/slapd/back-wt/compare.c
new file mode 100644
index 0000000..038b273
--- /dev/null
+++ b/servers/slapd/back-wt/compare.c
@@ -0,0 +1,154 @@
+/* OpenLDAP WiredTiger backend */
+/* $OpenLDAP$ */
+/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
+ *
+ * Copyright 2002-2022 The OpenLDAP Foundation.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted only as authorized by the OpenLDAP
+ * Public License.
+ *
+ * A copy of this license is available in the file LICENSE in the
+ * top-level directory of the distribution or, alternatively, at
+ * <http://www.OpenLDAP.org/license.html>.
+ */
+/* ACKNOWLEDGEMENTS:
+ * This work was developed by HAMANO Tsukasa <hamano@osstech.co.jp>
+ * based on back-bdb for inclusion in OpenLDAP Software.
+ * WiredTiger is a product of MongoDB Inc.
+ */
+
+#include "portable.h"
+
+#include <stdio.h>
+#include <ac/string.h>
+
+#include "back-wt.h"
+#include "slap-config.h"
+
+int
+wt_compare( Operation *op, SlapReply *rs )
+{
+    struct wt_info *wi = (struct wt_info *) op->o_bd->be_private;
+	Entry *e = NULL;
+	int manageDSAit = get_manageDSAit( op );
+	int rc;
+	wt_ctx *wc = NULL;
+
+	Debug( LDAP_DEBUG_ARGS, "==> wt_compare: %s\n",
+		   op->o_req_dn.bv_val );
+
+	wc = wt_ctx_get(op, wi);
+	if( !wc ){
+		Debug( LDAP_DEBUG_ANY, "wt_compare: wt_ctx_get failed\n" );
+		rs->sr_err = LDAP_OTHER;
+		rs->sr_text = "internal error";
+        send_ldap_result( op, rs );
+        return rs->sr_err;
+	}
+
+	rc = wt_dn2entry(op->o_bd, wc, &op->o_req_ndn, &e);
+	switch( rc ) {
+	case 0:
+	case WT_NOTFOUND:
+		break;
+	default:
+		rs->sr_err = LDAP_OTHER;
+		rs->sr_text = "internal error";
+		goto return_results;
+	}
+
+	if ( rc == WT_NOTFOUND ||
+		 (!manageDSAit && e && is_entry_glue( e ) )) {
+
+		if ( !e ) {
+			rc = wt_dn2aentry(op->o_bd, wc, &op->o_req_ndn, &e);
+			switch( rc ) {
+			case 0:
+				break;
+			case WT_NOTFOUND:
+				rs->sr_err = LDAP_NO_SUCH_OBJECT;
+				goto return_results;
+			default:
+				Debug( LDAP_DEBUG_ANY, "wt_compare: wt_dn2aentry failed (%d)\n",
+					   rc );
+				rs->sr_err = LDAP_OTHER;
+				rs->sr_text = "internal error";
+				goto return_results;
+			}
+		}
+
+		/* return referral only if "disclose" is granted on the object */
+		if ( ! access_allowed( op, e, slap_schema.si_ad_entry,
+							   NULL, ACL_DISCLOSE, NULL ) )
+		{
+			rs->sr_err = LDAP_NO_SUCH_OBJECT;
+		} else {
+			rs->sr_matched = ch_strdup( e->e_dn );
+			if ( is_entry_referral( e )) {
+				BerVarray ref = get_entry_referrals( op, e );
+				rs->sr_ref = referral_rewrite( ref,
+											   &e->e_name,
+											   &op->o_req_dn,
+											   LDAP_SCOPE_DEFAULT );
+				ber_bvarray_free( ref );
+			} else {
+				rs->sr_ref = NULL;
+			}
+			rs->sr_err = LDAP_REFERRAL;
+		}
+		rs->sr_flags = REP_MATCHED_MUSTBEFREED | REP_REF_MUSTBEFREED;
+		send_ldap_result( op, rs );
+		goto done;
+	}
+
+	if (!manageDSAit && is_entry_referral( e ) ) {
+		/* return referral only if "disclose" is granted on the object */
+		if ( !access_allowed( op, e, slap_schema.si_ad_entry,
+							  NULL, ACL_DISCLOSE, NULL ) )
+		{
+			rs->sr_err = LDAP_NO_SUCH_OBJECT;
+		} else {
+			/* entry is a referral, don't allow compare */
+			rs->sr_ref = get_entry_referrals( op, e );
+			rs->sr_err = LDAP_REFERRAL;
+			rs->sr_matched = e->e_name.bv_val;
+		}
+
+		Debug( LDAP_DEBUG_TRACE, "entry is referral\n" );
+
+		send_ldap_result( op, rs );
+
+		ber_bvarray_free( rs->sr_ref );
+		rs->sr_ref = NULL;
+		rs->sr_matched = NULL;
+		goto done;
+	}
+
+	rs->sr_err = slap_compare_entry( op, e, op->orc_ava );
+
+return_results:
+	send_ldap_result( op, rs );
+
+	switch ( rs->sr_err ) {
+	case LDAP_COMPARE_FALSE:
+	case LDAP_COMPARE_TRUE:
+		rs->sr_err = LDAP_SUCCESS;
+		break;
+	}
+
+done:
+	if ( e != NULL ) {
+		wt_entry_return( e );
+	}
+    return rs->sr_err;
+}
+
+/*
+ * Local variables:
+ * indent-tabs-mode: t
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */
diff --git a/servers/slapd/back-wt/config.c b/servers/slapd/back-wt/config.c
new file mode 100644
index 0000000..804e25b
--- /dev/null
+++ b/servers/slapd/back-wt/config.c
@@ -0,0 +1,209 @@
+/* OpenLDAP WiredTiger backend */
+/* $OpenLDAP$ */
+/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
+ *
+ * Copyright 2002-2022 The OpenLDAP Foundation.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted only as authorized by the OpenLDAP
+ * Public License.
+ *
+ * A copy of this license is available in the file LICENSE in the
+ * top-level directory of the distribution or, alternatively, at
+ * <http://www.OpenLDAP.org/license.html>.
+ */
+/* ACKNOWLEDGEMENTS:
+ * This work was developed by HAMANO Tsukasa <hamano@osstech.co.jp>
+ * based on back-bdb for inclusion in OpenLDAP Software.
+ * WiredTiger is a product of MongoDB Inc.
+ */
+
+#include "portable.h"
+
+#include <stdio.h>
+#include <ac/string.h>
+#include "back-wt.h"
+#include "slap-config.h"
+
+#include "lutil.h"
+#include "ldap_rq.h"
+
+static ConfigDriver wt_cf_gen;
+
+enum {
+	WT_DIRECTORY = 1,
+	WT_CONFIG,
+	WT_INDEX,
+	WT_MODE,
+	WT_IDLCACHE,
+};
+
+static ConfigTable wtcfg[] = {
+    { "directory", "dir", 2, 2, 0, ARG_STRING|ARG_MAGIC|WT_DIRECTORY,
+	  wt_cf_gen, "( OLcfgDbAt:0.1 NAME 'olcDbDirectory' "
+	  "DESC 'Directory for database content' "
+	  "EQUALITY caseIgnoreMatch "
+	  "SYNTAX OMsDirectoryString SINGLE-VALUE )", NULL, NULL },
+	{ "index", "attr> <[pres,eq,approx,sub]", 2, 3, 0, ARG_MAGIC|WT_INDEX,
+	  wt_cf_gen, "( OLcfgDbAt:0.2 NAME 'olcDbIndex' "
+	  "DESC 'Attribute index parameters' "
+	  "EQUALITY caseIgnoreMatch "
+	  "SYNTAX OMsDirectoryString )", NULL, NULL },
+	{ "mode", "mode", 2, 2, 0, ARG_MAGIC|WT_MODE,
+	  wt_cf_gen, "( OLcfgDbAt:0.3 NAME 'olcDbMode' "
+	  "DESC 'Unix permissions of database files' "
+	  "SYNTAX OMsDirectoryString SINGLE-VALUE )", NULL, NULL },
+	{ "wtconfig", "config", 2, 2, 0, ARG_STRING|ARG_MAGIC|WT_CONFIG,
+	  wt_cf_gen, "( OLcfgDbAt:13.1 NAME 'olcWtConfig' "
+	  "DESC 'Configuration for WiredTiger' "
+	  "EQUALITY caseIgnoreMatch "
+	  "SYNTAX OMsDirectoryString SINGLE-VALUE )", NULL, NULL },
+	{ "idlcache", NULL, 1, 2, 0, ARG_ON_OFF|ARG_MAGIC|WT_IDLCACHE,
+	  wt_cf_gen, "( OLcfgDbAt:13.2 NAME 'olcIDLcache' "
+	  "DESC 'enable IDL cache' "
+	  "SYNTAX OMsBoolean SINGLE-VALUE )", NULL, NULL },
+	{ NULL, NULL, 0, 0, 0, ARG_IGNORED,
+		NULL, NULL, NULL, NULL }
+};
+
+static ConfigOCs wtocs[] = {
+	{ "( OLcfgDbOc:13.1 "
+	  "NAME 'olcWtConfig' "
+	  "DESC 'Wt backend configuration' "
+	  "SUP olcDatabaseConfig "
+	  "MUST olcDbDirectory "
+	  "MAY ( olcWtConfig $ olcDbIndex $ olcDbMode $ olcIDLcache) )",
+	  Cft_Database, wtcfg },
+	{ NULL, 0, NULL }
+};
+
+/* reindex entries on the fly */
+static void *
+wt_online_index( void *ctx, void *arg )
+{
+	// Not implement yet
+	return NULL;
+}
+
+/* Cleanup loose ends after Modify completes */
+static int
+wt_cf_cleanup( ConfigArgs *c )
+{
+	// Not implement yet
+	return 0;
+}
+
+static int
+wt_cf_gen( ConfigArgs *c )
+{
+	struct wt_info *wi = (struct wt_info *) c->be->be_private;
+	int rc;
+
+	if( c->op == SLAP_CONFIG_EMIT ) {
+		rc = 0;
+		switch( c->type ) {
+		case WT_DIRECTORY:
+			if ( wi->wi_home ) {
+				c->value_string = ch_strdup( wi->wi_home );
+			} else {
+				rc = 1;
+			}
+			break;
+		case WT_INDEX:
+			wt_attr_index_unparse( wi, &c->rvalue_vals );
+			if ( !c->rvalue_vals ) rc = 1;
+			break;
+		case WT_IDLCACHE:
+			if ( wi->wi_flags & WT_USE_IDLCACHE) {
+				c->value_int = 1;
+			}
+			break;
+		}
+		return rc;
+	} else if ( c->op == LDAP_MOD_DELETE ) {
+		rc = 0;
+		return rc;
+	}
+
+	switch( c->type ) {
+	case WT_DIRECTORY:
+		ch_free( wi->wi_home );
+		wi->wi_home = c->value_string;
+		break;
+	case WT_CONFIG:
+		if(strlen(wi->wi_config) + 1 + strlen(c->value_string) > WT_CONFIG_MAX){
+			fprintf( stderr, "%s: "
+					 "\"wtconfig\" are too long. Increase WT_CONFIG_MAX or you may realloc the buffer.\n",
+					 c->log );
+			return 1;
+		}
+		/* size of wi->wi_config is WT_CONFIG_MAX + 1, it's guaranteed with NUL-terminate. */
+		strcat(wi->wi_config, ",");
+		strcat(wi->wi_config, c->value_string);
+		break;
+
+	case WT_INDEX:
+		rc = wt_attr_index_config( wi, c->fname, c->lineno,
+								   c->argc - 1, &c->argv[1], &c->reply);
+
+		if( rc != LDAP_SUCCESS ) return 1;
+		wi->wi_flags |= WT_OPEN_INDEX;
+
+		if ( wi->wi_flags & WT_IS_OPEN ) {
+			config_push_cleanup( c, wt_cf_cleanup );
+
+			if ( !wi->wi_index_task ) {
+				/* Start the task as soon as we finish here. Set a long
+                 * interval (10 hours) so that it only gets scheduled once.
+                 */
+				if ( c->be->be_suffix == NULL || BER_BVISNULL( &c->be->be_suffix[0] ) ) {
+					fprintf( stderr, "%s: "
+							 "\"index\" must occur after \"suffix\".\n",
+							 c->log );
+					return 1;
+				}
+				ldap_pvt_thread_mutex_lock( &slapd_rq.rq_mutex );
+				wi->wi_index_task = ldap_pvt_runqueue_insert(&slapd_rq, 36000,
+															 wt_online_index, c->be,
+															 LDAP_XSTRING(wt_online_index),
+															 c->be->be_suffix[0].bv_val );
+				ldap_pvt_thread_mutex_unlock( &slapd_rq.rq_mutex );
+			}
+		}
+		break;
+
+	case WT_MODE:
+		fprintf( stderr, "%s: "
+				 "back-wt does not support \"mode\" option. use umask instead.\n",
+				 c->log );
+		return 1;
+
+	case WT_IDLCACHE:
+		if ( c->value_int ) {
+			wi->wi_flags |= WT_USE_IDLCACHE;
+		} else {
+			wi->wi_flags &= ~WT_USE_IDLCACHE;
+		}
+		break;
+	}
+	return LDAP_SUCCESS;
+}
+
+int wt_back_init_cf( BackendInfo *bi )
+{
+	int rc;
+	bi->bi_cf_ocs = wtocs;
+
+	rc = config_register_schema( wtcfg, wtocs );
+	if ( rc ) return rc;
+	return 0;
+}
+
+/*
+ * Local variables:
+ * indent-tabs-mode: t
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */
diff --git a/servers/slapd/back-wt/ctx.c b/servers/slapd/back-wt/ctx.c
new file mode 100644
index 0000000..de6578e
--- /dev/null
+++ b/servers/slapd/back-wt/ctx.c
@@ -0,0 +1,117 @@
+/* OpenLDAP WiredTiger backend */
+/* $OpenLDAP$ */
+/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
+ *
+ * Copyright 2002-2022 The OpenLDAP Foundation.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted only as authorized by the OpenLDAP
+ * Public License.
+ *
+ * A copy of this license is available in the file LICENSE in the
+ * top-level directory of the distribution or, alternatively, at
+ * <http://www.OpenLDAP.org/license.html>.
+ */
+/* ACKNOWLEDGEMENTS:
+ * This work was developed by HAMANO Tsukasa <hamano@osstech.co.jp>
+ * based on back-bdb for inclusion in OpenLDAP Software.
+ * WiredTiger is a product of MongoDB Inc.
+ */
+
+#include "back-wt.h"
+#include "slap-config.h"
+
+wt_ctx *
+wt_ctx_init(struct wt_info *wi)
+{
+	int rc;
+	wt_ctx *wc;
+
+	wc = ch_malloc( sizeof( wt_ctx ) );
+	if( !wc ) {
+		Debug( LDAP_DEBUG_ANY, "wt_ctx_init: cannot allocate memory\n" );
+		return NULL;
+	}
+
+	memset(wc, 0, sizeof(wt_ctx));
+
+	rc = wi->wi_conn->open_session(wi->wi_conn, NULL, NULL, &wc->session);
+	if( rc ) {
+		Debug( LDAP_DEBUG_ANY, "wt_ctx_init: open_session error %s(%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		return NULL;
+	}
+
+	/* readonly mode */
+	if (!wi->wi_cache) {
+		return wc;
+	}
+
+	rc = wi->wi_cache->open_session(wi->wi_cache, NULL, NULL, &wc->idlcache_session);
+	if( rc ) {
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_ctx_init: cannot open idlcache session %s(%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		return NULL;
+	}
+
+	return wc;
+}
+
+void
+wt_ctx_free( void *key, void *data )
+{
+	wt_ctx *wc = data;
+
+	if(wc->session){
+		/*
+		 * The session will close automatically when db closing.
+		 * We can close session here, but it's require to check db
+		 * status, otherwise it will cause SEGV.
+		 */
+		/*
+		if(IS_DB_OPEN) {
+		    wc->session->close(wc->session, NULL);
+		}
+		*/
+		wc->session = NULL;
+	}
+
+	ch_free(wc);
+}
+
+wt_ctx *
+wt_ctx_get(Operation *op, struct wt_info *wi){
+	int rc;
+	void *data;
+	wt_ctx *wc = NULL;
+
+	rc = ldap_pvt_thread_pool_getkey(op->o_threadctx,
+									 wi, &data, NULL );
+	if( rc ){
+		wc = wt_ctx_init(wi);
+		if( !wc ) {
+			Debug( LDAP_DEBUG_ANY, "wt_ctx: wt_ctx_init failed\n" );
+			return NULL;
+		}
+		rc = ldap_pvt_thread_pool_setkey( op->o_threadctx,
+										  wi, wc, wt_ctx_free,
+										  NULL, NULL );
+		if( rc ) {
+			Debug( LDAP_DEBUG_ANY, "wt_ctx: setkey error(%d)\n",
+				   rc );
+			return NULL;
+		}
+		return wc;
+	}
+	return (wt_ctx *)data;
+}
+
+/*
+ * Local variables:
+ * indent-tabs-mode: t
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */
diff --git a/servers/slapd/back-wt/delete.c b/servers/slapd/back-wt/delete.c
new file mode 100644
index 0000000..9673662
--- /dev/null
+++ b/servers/slapd/back-wt/delete.c
@@ -0,0 +1,419 @@
+/* OpenLDAP WiredTiger backend */
+/* $OpenLDAP$ */
+/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
+ *
+ * Copyright 2002-2022 The OpenLDAP Foundation.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted only as authorized by the OpenLDAP
+ * Public License.
+ *
+ * A copy of this license is available in the file LICENSE in the
+ * top-level directory of the distribution or, alternatively, at
+ * <http://www.OpenLDAP.org/license.html>.
+ */
+/* ACKNOWLEDGEMENTS:
+ * This work was developed by HAMANO Tsukasa <hamano@osstech.co.jp>
+ * based on back-bdb for inclusion in OpenLDAP Software.
+ * WiredTiger is a product of MongoDB Inc.
+ */
+
+#include "portable.h"
+
+#include <stdio.h>
+#include <ac/string.h>
+
+#include "back-wt.h"
+#include "slap-config.h"
+
+int
+wt_delete( Operation *op, SlapReply *rs )
+{
+    struct wt_info *wi = (struct wt_info *) op->o_bd->be_private;
+	struct berval   pdn = {0, NULL};
+	Entry *e = NULL;
+	Entry *p = NULL;
+	int manageDSAit = get_manageDSAit( op );
+	AttributeDescription *children = slap_schema.si_ad_children;
+	AttributeDescription *entry = slap_schema.si_ad_entry;
+
+	LDAPControl **preread_ctrl = NULL;
+	LDAPControl *ctrls[SLAP_MAX_RESPONSE_CONTROLS];
+	int num_ctrls = 0;
+
+	wt_ctx *wc;
+	int rc;
+
+	int parent_is_glue = 0;
+	int parent_is_leaf = 0;
+
+	Debug( LDAP_DEBUG_ARGS, "==> wt_delete: %s\n",
+		   op->o_req_dn.bv_val );
+
+	if( op->o_txnSpec && txn_preop( op, rs ))
+		return rs->sr_err;
+
+	ctrls[num_ctrls] = 0;
+	rs->sr_text = NULL;
+
+	wc = wt_ctx_get(op, wi);
+	if( !wc ){
+        Debug( LDAP_DEBUG_TRACE, "wt_delete: wt_ctx_get failed\n" );
+		rs->sr_err = LDAP_OTHER;
+		rs->sr_text = "internal error";
+		goto return_results;
+	}
+
+/* allocate CSN */
+	if ( BER_BVISNULL( &op->o_csn ) ) {
+		struct berval csn;
+		char csnbuf[LDAP_PVT_CSNSTR_BUFSIZE];
+
+		csn.bv_val = csnbuf;
+		csn.bv_len = sizeof(csnbuf);
+		slap_get_csn( op, &csn, 1 );
+	}
+
+	if ( !be_issuffix( op->o_bd, &op->o_req_ndn ) ) {
+		dnParent( &op->o_req_ndn, &pdn );
+	}
+
+	/* get parent */
+	rc = wt_dn2entry(op->o_bd, wc, &pdn, &p);
+	switch( rc ) {
+	case 0:
+	case WT_NOTFOUND:
+		break;
+	default:
+		rs->sr_err = LDAP_OTHER;
+		rs->sr_text = "internal error";
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_delete: error at wt_dn2entry() rc=%d\n", rc );
+		goto return_results;
+	}
+
+	if ( rc == WT_NOTFOUND && pdn.bv_len != 0 ) {
+		Debug( LDAP_DEBUG_ARGS,
+			   "<== wt_delete: parent not found %s\n", op->o_req_dn.bv_val );
+		rc = wt_dn2aentry(op->o_bd, wc, &op->o_req_ndn, &e);
+		Debug( LDAP_DEBUG_ARGS, "<== wt_delete: rc=%d\n", rc );
+
+		switch( rc ) {
+		case 0:
+			break;
+		case WT_NOTFOUND:
+			rs->sr_err = LDAP_NO_SUCH_OBJECT;
+			goto return_results;
+		default:
+			Debug( LDAP_DEBUG_ANY, "wt_delete: wt_dn2aentry failed (%d)\n", rc );
+			rs->sr_err = LDAP_OTHER;
+			rs->sr_text = "internal error";
+			goto return_results;
+		}
+
+		if ( e && !BER_BVISEMPTY( &e->e_name )) {
+			rs->sr_matched = ch_strdup( e->e_name.bv_val );
+			if ( is_entry_referral( e )) {
+				BerVarray ref = get_entry_referrals( op, e );
+				rs->sr_ref = referral_rewrite( ref, &e->e_name,
+											   &op->o_req_dn, LDAP_SCOPE_DEFAULT );
+				ber_bvarray_free( ref );
+			} else {
+				rs->sr_ref = NULL;
+			}
+		} else {
+			rs->sr_ref = referral_rewrite( default_referral, NULL,
+										   &op->o_req_dn, LDAP_SCOPE_DEFAULT );
+		}
+
+		rs->sr_err = LDAP_REFERRAL;
+		rs->sr_flags = REP_MATCHED_MUSTBEFREED | REP_REF_MUSTBEFREED;
+		goto return_results;
+	}
+
+	/* get entry */
+	rc = wt_dn2entry(op->o_bd, wc, &op->o_req_ndn, &e);
+	switch( rc ) {
+	case 0:
+		break;
+	case WT_NOTFOUND:
+		break;
+	default:
+		rs->sr_err = LDAP_OTHER;
+		rs->sr_text = "internal error";
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_delete: error at wt_dn2entry() rc=%d\n", rc );
+		goto return_results;
+	}
+
+	/* FIXME : dn2entry() should return non-glue entry */
+	if (rc == WT_NOTFOUND ||
+		( !manageDSAit && e && is_entry_glue( e ) )) {
+		if ( !e ) {
+			Debug( LDAP_DEBUG_ARGS,
+				   "<== wt_delete: no such object %s\n",
+				   op->o_req_dn.bv_val);
+			rc = wt_dn2aentry(op->o_bd, wc, &op->o_req_ndn, &e);
+			switch( rc ) {
+			case 0:
+				break;
+			case WT_NOTFOUND:
+				rs->sr_err = LDAP_NO_SUCH_OBJECT;
+				goto return_results;
+			default:
+				Debug( LDAP_DEBUG_ANY, "wt_delete: wt_dn2aentry failed (%d)\n", rc );
+				rs->sr_err = LDAP_OTHER;
+				rs->sr_text = "internal error";
+				goto return_results;
+			}
+		}
+
+		rs->sr_matched = ch_strdup( e->e_dn );
+		if ( is_entry_referral( e )) {
+			BerVarray ref = get_entry_referrals( op, e );
+			rs->sr_ref = referral_rewrite( ref, &e->e_name,
+										   &op->o_req_dn, LDAP_SCOPE_DEFAULT );
+			ber_bvarray_free( ref );
+		} else {
+			rs->sr_ref = NULL;
+		}
+
+		rs->sr_err = LDAP_REFERRAL;
+		rs->sr_flags = REP_MATCHED_MUSTBEFREED | REP_REF_MUSTBEFREED;
+		goto return_results;
+	}
+
+	if ( pdn.bv_len != 0 ) {
+		/* check parent for "children" acl */
+		rs->sr_err = access_allowed( op, p,
+									 children, NULL, ACL_WDEL, NULL );
+
+		if ( !rs->sr_err  ) {
+			Debug( LDAP_DEBUG_TRACE,
+				   "<== wt_delete: no write access to parent\n" );
+			rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
+			rs->sr_text = "no write access to parent";
+			goto return_results;
+		}
+
+	} else {
+		/* no parent, must be root to delete */
+		if( ! be_isroot( op ) ) {
+			if ( be_issuffix( op->o_bd, (struct berval *)&slap_empty_bv )
+				 || be_shadow_update( op ) ) {
+				p = (Entry *)&slap_entry_root;
+
+				/* check parent for "children" acl */
+				rs->sr_err = access_allowed( op, p,
+											 children, NULL, ACL_WDEL, NULL );
+
+				p = NULL;
+
+				if ( !rs->sr_err  ) {
+					Debug( LDAP_DEBUG_TRACE,
+						   "<== wt_delete: no access to parent\n" );
+					rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
+					rs->sr_text = "no write access to parent";
+					goto return_results;
+				}
+
+			} else {
+				Debug( LDAP_DEBUG_TRACE,
+					   "<== wt_delete: no parent and not root\n" );
+				rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
+				goto return_results;
+			}
+		}
+	}
+
+	if ( get_assert( op ) &&
+		 ( test_filter( op, e, get_assertion( op )) != LDAP_COMPARE_TRUE ))
+	{
+		rs->sr_err = LDAP_ASSERTION_FAILED;
+		goto return_results;
+	}
+
+	rs->sr_err = access_allowed( op, e,
+								 entry, NULL, ACL_WDEL, NULL );
+	if ( !rs->sr_err  ) {
+		Debug( LDAP_DEBUG_TRACE,
+			   "<== wt_delete: no write access to entry\n" );
+		rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
+		rs->sr_text = "no write access to entry";
+		goto return_results;
+	}
+
+	if ( !manageDSAit && is_entry_referral( e ) ) {
+		/* entry is a referral, don't allow delete */
+		rs->sr_ref = get_entry_referrals( op, e );
+
+		Debug( LDAP_DEBUG_TRACE, "wt_delete: entry is referral\n" );
+
+		rs->sr_err = LDAP_REFERRAL;
+		rs->sr_matched = ch_strdup( e->e_name.bv_val );
+		rs->sr_flags = REP_MATCHED_MUSTBEFREED | REP_REF_MUSTBEFREED;
+		goto return_results;
+	}
+
+	/* pre-read */
+	if( op->o_preread ) {
+		if( preread_ctrl == NULL ) {
+			preread_ctrl = &ctrls[num_ctrls++];
+			ctrls[num_ctrls] = NULL;
+		}
+		if( slap_read_controls( op, rs, e,
+								&slap_pre_read_bv, preread_ctrl ) )
+		{
+			Debug( LDAP_DEBUG_TRACE,
+				   "<== wt_delete: pre-read failed!\n" );
+			if ( op->o_preread & SLAP_CONTROL_CRITICAL ) {
+				/* FIXME: is it correct to abort
+                 * operation if control fails? */
+				goto return_results;
+			}
+		}
+	}
+
+    /* Can't do it if we have kids */
+	rc = wt_dn2id_has_children( op, wc, e->e_id );
+	if( rc != WT_NOTFOUND ) {
+		switch( rc ) {
+		case 0:
+			Debug(LDAP_DEBUG_ARGS,
+				  "<== wt_delete: non-leaf %s\n", op->o_req_dn.bv_val );
+			rs->sr_err = LDAP_NOT_ALLOWED_ON_NONLEAF;
+			rs->sr_text = "subordinate objects must be deleted first";
+			break;
+		default:
+			Debug(LDAP_DEBUG_ARGS,
+				  "<== wt_delete: has_children failed: %s (%d)\n",
+				  wiredtiger_strerror(rc), rc );
+			rs->sr_err = LDAP_OTHER;
+			rs->sr_text = "internal error";
+		}
+		goto return_results;
+	}
+
+	/* begin transaction */
+	rc = wc->session->begin_transaction(wc->session, NULL);
+	if( rc ) {
+		Debug( LDAP_DEBUG_TRACE,
+			   "wt_delete: begin_transaction failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		rs->sr_err = LDAP_OTHER;
+		rs->sr_text = "begin_transaction failed";
+		goto return_results;
+	}
+
+	/* delete from dn2id */
+	rc = wt_dn2id_delete( op, wc, &op->o_req_ndn);
+	if ( rc ) {
+		Debug(LDAP_DEBUG_TRACE,
+			  "<== wt_delete: dn2id failed: %s (%d)\n",
+			  wiredtiger_strerror(rc), rc );
+		rs->sr_err = LDAP_OTHER;
+		rs->sr_text = "dn2id delete failed";
+		wc->session->rollback_transaction(wc->session, NULL);
+		goto return_results;
+	}
+
+	/* delete indices for old attributes */
+	rc = wt_index_entry_del( op, wc, e );
+	if ( rc ) {
+		Debug(LDAP_DEBUG_TRACE,
+			  "<== wt_delete: index delete failed: %s (%d)\n",
+			  wiredtiger_strerror(rc), rc );
+		rs->sr_err = LDAP_OTHER;
+		rs->sr_text = "index delete failed";
+		wc->session->rollback_transaction(wc->session, NULL);
+		goto return_results;
+	}
+
+	/* fixup delete CSN */
+	if ( !SLAP_SHADOW( op->o_bd )) {
+		struct berval vals[2];
+
+		assert( !BER_BVISNULL( &op->o_csn ) );
+		vals[0] = op->o_csn;
+		BER_BVZERO( &vals[1] );
+		rs->sr_err = wt_index_values( op, wc, slap_schema.si_ad_entryCSN,
+									  vals, 0, SLAP_INDEX_ADD_OP );
+		if ( rs->sr_err != LDAP_SUCCESS ) {
+			rs->sr_text = "entryCSN index update failed";
+			rs->sr_err = LDAP_OTHER;
+			wc->session->rollback_transaction(wc->session, NULL);
+			goto return_results;
+		}
+	}
+
+	/* delete from id2entry */
+	rc = wt_id2entry_delete( op, wc, e );
+	if ( rc ) {
+		Debug( LDAP_DEBUG_TRACE,
+			   "<== wt_delete: id2entry failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		rs->sr_err = LDAP_OTHER;
+		rs->sr_text = "entry delete failed";
+		wc->session->rollback_transaction(wc->session, NULL);
+		goto return_results;
+	}
+
+	if ( pdn.bv_len != 0 ) {
+		// TODO: glue entry
+	}
+
+	rc = wc->session->commit_transaction(wc->session, NULL);
+	if( rc ) {
+		Debug( LDAP_DEBUG_TRACE,
+			   "<== wt_delete: commit_transaction failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		rs->sr_err = LDAP_OTHER;
+		rs->sr_text = "commit_transaction failed";
+		goto return_results;
+	}
+
+	Debug( LDAP_DEBUG_TRACE,
+		   "wt_delete: deleted%s id=%08lx dn=\"%s\"\n",
+		   op->o_noop ? " (no-op)" : "", e->e_id, op->o_req_dn.bv_val );
+
+	rs->sr_err = LDAP_SUCCESS;
+	rs->sr_text = NULL;
+	if( num_ctrls ) {
+		rs->sr_ctrls = ctrls;
+	}
+
+return_results:
+	if ( rs->sr_err == LDAP_SUCCESS && parent_is_glue && parent_is_leaf ) {
+		op->o_delete_glue_parent = 1;
+	}
+
+	if ( p != NULL ) {
+		wt_entry_return( p );
+	}
+
+	/* free entry */
+	if( e != NULL ) {
+		wt_entry_return( e );
+	}
+
+	send_ldap_result( op, rs );
+	slap_graduate_commit_csn( op );
+
+	if( preread_ctrl != NULL && (*preread_ctrl) != NULL ) {
+		slap_sl_free( (*preread_ctrl)->ldctl_value.bv_val, op->o_tmpmemctx );
+		slap_sl_free( *preread_ctrl, op->o_tmpmemctx );
+	}
+
+	/* TODO: checkpoint */
+
+	return rs->sr_err;
+}
+
+/*
+ * Local variables:
+ * indent-tabs-mode: t
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */
diff --git a/servers/slapd/back-wt/dn2entry.c b/servers/slapd/back-wt/dn2entry.c
new file mode 100644
index 0000000..84cb13d
--- /dev/null
+++ b/servers/slapd/back-wt/dn2entry.c
@@ -0,0 +1,176 @@
+/* OpenLDAP WiredTiger backend */
+/* $OpenLDAP$ */
+/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
+ *
+ * Copyright 2002-2022 The OpenLDAP Foundation.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted only as authorized by the OpenLDAP
+ * Public License.
+ *
+ * A copy of this license is available in the file LICENSE in the
+ * top-level directory of the distribution or, alternatively, at
+ * <http://www.OpenLDAP.org/license.html>.
+ */
+/* ACKNOWLEDGEMENTS:
+ * This work was developed by HAMANO Tsukasa <hamano@osstech.co.jp>
+ * based on back-bdb for inclusion in OpenLDAP Software.
+ * WiredTiger is a product of MongoDB Inc.
+ */
+
+#include "portable.h"
+
+#include <stdio.h>
+#include <ac/string.h>
+#include "back-wt.h"
+#include "slap-config.h"
+
+/*
+ * dn2entry - look up dn in the db and return the corresponding entry.
+ * No longer return closest ancestor, see wt_dn2pentry().
+ */
+int wt_dn2entry( BackendDB *be,
+				 wt_ctx *wc,
+				 struct berval *ndn,
+				 Entry **ep ){
+	uint64_t id;
+	WT_ITEM item;
+	EntryHeader eh;
+	int rc;
+	int eoff;
+	Entry *e = NULL;
+	WT_SESSION *session = wc->session;
+	WT_CURSOR *cursor = wc->dn2entry;
+
+	if( ndn->bv_len == 0 ){
+		/* empty dn */
+		e = entry_alloc();
+		ber_dupbv(&e->e_nname, ndn);
+		*ep = e;
+		return LDAP_SUCCESS;
+	}
+
+	if(!cursor){
+		rc = session->open_cursor(session,
+								  WT_INDEX_DN"(id, entry)",
+								  NULL, NULL, &cursor);
+		if ( rc ) {
+			Debug( LDAP_DEBUG_ANY,
+				   "wt_dn2entry: open_cursor failed: %s (%d)\n",
+				   wiredtiger_strerror(rc), rc );
+			goto done;
+		}
+		wc->dn2entry = cursor;
+	}
+
+	cursor->set_key(cursor, ndn->bv_val);
+	rc = cursor->search(cursor);
+	switch( rc ){
+	case 0:
+		break;
+	case WT_NOTFOUND:
+		goto done;
+	default:
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_dn2entry: search failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		goto done;
+	}
+	cursor->get_value(cursor, &id, &item);
+	rc = wt_entry_header( &item,  &eh );
+
+	eoff = eh.data - (char *)item.data;
+	eh.bv.bv_len = eh.nvals * sizeof( struct berval ) + item.size;
+	eh.bv.bv_val = ch_malloc( eh.bv.bv_len );
+	memset(eh.bv.bv_val, 0xff, eh.bv.bv_len);
+	eh.data = eh.bv.bv_val + eh.nvals * sizeof( struct berval );
+	memcpy(eh.data, item.data, item.size);
+	eh.data += eoff;
+	rc = entry_decode( &eh, &e );
+	if ( rc ) {
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_dn2entry: entry decode error: %d\n", rc );
+		goto done;
+	}
+
+	e->e_id = id;
+	*ep = e;
+
+done:
+
+#ifdef WT_CURSOR_CACHE
+	if(cursor){
+		cursor->reset(cursor);
+	}
+#else
+	if(cursor){
+		cursor->close(cursor);
+		wc->dn2entry = NULL;
+	}
+#endif
+	return rc;
+}
+
+/* dn2pentry - return parent entry */
+int wt_dn2pentry( BackendDB *be,
+				  wt_ctx *wc,
+				  struct berval *ndn,
+				  Entry **ep ){
+	Entry *e = NULL;
+	struct berval pdn;
+	int rc;
+
+	if (be_issuffix( be, ndn )) {
+		*ep = NULL;
+		return WT_NOTFOUND;
+	}
+
+	dnParent( ndn, &pdn );
+	rc = wt_dn2entry(be, wc, &pdn, &e);
+	*ep = e;
+	return rc;
+}
+
+/* dn2aentry - return ancestor entry */
+int wt_dn2aentry( BackendDB *be,
+				  wt_ctx *wc,
+				  struct berval *ndn,
+				  Entry **ep ) {
+	Entry *e = NULL;
+	struct berval pdn;
+	int rc;
+
+	if (be_issuffix( be, ndn )) {
+		*ep = NULL;
+		return 0;
+	}
+
+	dnParent( ndn, &pdn );
+	rc = wt_dn2entry(be, wc, &pdn, &e);
+	switch( rc ) {
+	case 0:
+		*ep = e;
+		break;
+	case WT_NOTFOUND:
+		rc = wt_dn2aentry(be, wc, &pdn, &e);
+		if (rc != 0 && rc != WT_NOTFOUND) {
+			return rc;
+		}
+		*ep = e;
+		break;
+	default:
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_dn2aentry: failed %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+	}
+	return rc;
+}
+
+/*
+ * Local variables:
+ * indent-tabs-mode: t
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */
diff --git a/servers/slapd/back-wt/dn2id.c b/servers/slapd/back-wt/dn2id.c
new file mode 100644
index 0000000..d8765ce
--- /dev/null
+++ b/servers/slapd/back-wt/dn2id.c
@@ -0,0 +1,453 @@
+/* OpenLDAP WiredTiger backend */
+/* $OpenLDAP$ */
+/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
+ *
+ * Copyright 2002-2022 The OpenLDAP Foundation.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted only as authorized by the OpenLDAP
+ * Public License.
+ *
+ * A copy of this license is available in the file LICENSE in the
+ * top-level directory of the distribution or, alternatively, at
+ * <http://www.OpenLDAP.org/license.html>.
+ */
+/* ACKNOWLEDGEMENTS:
+ * This work was developed by HAMANO Tsukasa <hamano@osstech.co.jp>
+ * based on back-bdb for inclusion in OpenLDAP Software.
+ * WiredTiger is a product of MongoDB Inc.
+ */
+
+#include "portable.h"
+
+#include <stdio.h>
+#include "back-wt.h"
+#include "slap-config.h"
+#include "idl.h"
+
+static char *
+mkrevdn(struct berval src){
+	char *dst, *p;
+	char *rdn;
+	size_t rdn_len;
+
+	p = dst = ch_malloc(src.bv_len + 2);
+	while(src.bv_len){
+		rdn = ber_bvrchr( &src, ',' );
+		if (rdn) {
+			rdn_len = src.bv_len;
+			src.bv_len = rdn - src.bv_val;
+			rdn_len -= src.bv_len + 1;
+			rdn++;
+		}else{
+			/* first rdn */
+			rdn_len = src.bv_len;
+			rdn = src.bv_val;
+			src.bv_len = 0;
+		}
+		memcpy( p, rdn, rdn_len );
+		p += rdn_len;
+		*p++ = ',';
+	}
+	*p = '\0';
+	return dst;
+}
+
+int
+wt_dn2id_add(
+	Operation *op,
+	wt_ctx *wc,
+	ID pid,
+	Entry *e)
+{
+	struct wt_info *wi = (struct wt_info *) op->o_bd->be_private;
+	int rc;
+	WT_SESSION *session = wc->session;
+	WT_CURSOR *cursor = wc->dn2id_w;
+	char *revdn = NULL;
+
+	Debug( LDAP_DEBUG_TRACE, "=> wt_dn2id_add 0x%lx: \"%s\"\n",
+		   e->e_id, e->e_ndn );
+	assert( e->e_id != NOID );
+
+	/* make reverse dn */
+	revdn = mkrevdn(e->e_nname);
+
+	if(!cursor){
+		rc = session->open_cursor(session, WT_TABLE_DN2ID, NULL,
+								  "overwrite=false", &cursor);
+		if(rc){
+			Debug( LDAP_DEBUG_ANY,
+				   "wt_dn2id_add: open_cursor failed: %s (%d)\n",
+				   wiredtiger_strerror(rc), rc );
+			goto done;
+		}
+		wc->dn2id_w = cursor;
+	}
+	cursor->set_key(cursor, revdn);
+	cursor->set_value(cursor, e->e_ndn, e->e_id, pid);
+	rc = cursor->insert(cursor);
+	if(rc){
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_dn2id_add: insert failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		goto done;
+    }
+
+	if (wi->wi_flags & WT_USE_IDLCACHE) {
+		wt_idlcache_clear(op, wc, &e->e_nname);
+	}
+
+done:
+	if(revdn){
+		ch_free(revdn);
+	}
+
+#ifdef WT_CURSOR_CACHE
+	if(cursor){
+		cursor->reset(cursor);
+	}
+#else
+	if(cursor){
+		cursor->close(cursor);
+		wc->dn2id_w = NULL;
+	}
+#endif
+
+	Debug( LDAP_DEBUG_TRACE, "<= wt_dn2id_add 0x%lx: %d\n", e->e_id, rc );
+	return rc;
+}
+
+int
+wt_dn2id_delete(
+	Operation *op,
+	wt_ctx *wc,
+	struct berval *ndn)
+{
+	struct wt_info *wi = (struct wt_info *) op->o_bd->be_private;
+	int rc = 0;
+	WT_SESSION *session = wc->session;
+	WT_CURSOR *cursor = wc->dn2id_w;
+	char *revdn = NULL;
+
+	Debug( LDAP_DEBUG_TRACE, "=> wt_dn2id_delete %s\n", ndn->bv_val );
+
+	/* make reverse dn */
+	revdn = mkrevdn(*ndn);
+
+	if(!cursor){
+		rc = session->open_cursor(session, WT_TABLE_DN2ID, NULL,
+								  "overwrite=false", &cursor);
+		if ( rc ) {
+			Debug( LDAP_DEBUG_ANY,
+				   "wt_dn2id_delete: open_cursor failed: %s (%d)\n",
+				   wiredtiger_strerror(rc), rc );
+			goto done;
+		}
+		wc->dn2id_w = cursor;
+	}
+
+	cursor->set_key(cursor, revdn);
+	rc = cursor->remove(cursor);
+	if ( rc ) {
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_dn2id_delete: remove failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		goto done;
+	}
+
+	if (wi->wi_flags & WT_USE_IDLCACHE) {
+		wt_idlcache_clear(op, wc, ndn);
+	}
+
+	Debug( LDAP_DEBUG_TRACE,
+		   "<= wt_dn2id_delete %s: %d\n", ndn->bv_val, rc );
+done:
+	if(revdn){
+		ch_free(revdn);
+	}
+
+#ifdef WT_CURSOR_CACHE
+	if(cursor){
+		cursor->reset(cursor);
+	}
+#else
+	if(cursor){
+		cursor->close(cursor);
+		wc->dn2id_w = NULL;
+	}
+#endif
+	return rc;
+}
+
+int
+wt_dn2id(
+	Operation *op,
+	wt_ctx *wc,
+    struct berval *ndn,
+    ID *id)
+{
+	WT_SESSION *session = wc->session;
+	WT_CURSOR *cursor = wc->dn2id_ndn;
+	int rc = LDAP_SUCCESS;
+
+	Debug( LDAP_DEBUG_TRACE, "=> wt_dn2id(\"%s\")\n", ndn->bv_val );
+
+	if ( ndn->bv_len == 0 ) {
+		*id = 0;
+		goto done;
+	}
+
+	if(!cursor){
+		rc = session->open_cursor(session, WT_INDEX_NDN
+								  "(id)",
+								  NULL, NULL, &cursor);
+		if( rc ){
+			Debug( LDAP_DEBUG_ANY,
+				   "wt_dn2id: cursor open failed: %s (%d)\n",
+				   wiredtiger_strerror(rc), rc );
+			goto done;
+		}
+		wc->dn2id_ndn = cursor;
+	}
+
+	cursor->set_key(cursor, ndn->bv_val);
+	rc = cursor->search(cursor);
+	switch( rc ){
+	case 0:
+		break;
+	case WT_NOTFOUND:
+		goto done;
+	default:
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_dn2id: search failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		goto done;
+	}
+	rc = cursor->get_value(cursor, id);
+	if( rc ){
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_dn2id: get_value failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		goto done;
+	}
+
+done:
+
+#ifdef WT_CURSOR_CACHE
+	if(cursor){
+		cursor->reset(cursor);
+	}
+#else
+	if(cursor){
+		cursor->close(cursor);
+		wc->dn2id_ndn = NULL;
+	}
+#endif
+
+	if( rc ) {
+		Debug( LDAP_DEBUG_TRACE, "<= wt_dn2id: get failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+	} else {
+		Debug( LDAP_DEBUG_TRACE, "<= wt_dn2id: got id=0x%lx\n",
+			   *id );
+	}
+
+	return rc;
+}
+
+int
+wt_dn2id_has_children(
+	Operation *op,
+	wt_ctx *wc,
+	ID id )
+{
+	WT_SESSION *session = wc->session;
+	WT_CURSOR *cursor = wc->index_pid;
+	int rc;
+	uint64_t key = id;
+
+	if(!cursor){
+		rc = session->open_cursor(session, WT_INDEX_PID,
+								  NULL, NULL, &cursor);
+		if( rc ){
+			Debug( LDAP_DEBUG_ANY,
+				   "wt_dn2id_has_children: cursor open failed: %s (%d)\n",
+				   wiredtiger_strerror(rc), rc );
+			goto done;
+		}
+		wc->index_pid = cursor;
+	}
+
+	cursor->set_key(cursor, key);
+	rc = cursor->search(cursor);
+
+done:
+
+#ifdef WT_CURSOR_CACHE
+	if(cursor){
+		cursor->reset(cursor);
+	}
+#else
+	if(cursor){
+		cursor->close(cursor);
+		wc->index_pid = NULL;
+	}
+#endif
+
+	return rc;
+}
+
+int
+wt_dn2idl_db(
+	Operation *op,
+	wt_ctx *wc,
+	struct berval *ndn,
+	Entry *e,
+	ID *ids,
+	ID *stack)
+{
+	WT_SESSION *session = wc->session;
+	WT_CURSOR *cursor = wc->dn2id;
+	int rc;
+	char *revdn = NULL;
+	size_t revdn_len;
+	char *key;
+	ID id, pid;
+
+	Debug( LDAP_DEBUG_TRACE,
+		   "=> wt_dn2idl(\"%s\")\n",
+		   ndn->bv_val );
+
+	revdn = mkrevdn(*ndn);
+	revdn_len = strlen(revdn);
+
+	if ( !cursor ) {
+		rc = session->open_cursor(session, WT_TABLE_DN2ID"(id, pid)",
+								  NULL, NULL, &cursor);
+		if( rc ){
+			Debug( LDAP_DEBUG_ANY,
+				   "wt_dn2idl: cursor open failed: %s (%d)\n",
+				   wiredtiger_strerror(rc), rc );
+			goto done;
+		}
+		wc->dn2id = cursor;
+	}
+	cursor->set_key(cursor, revdn);
+	rc = cursor->search(cursor);
+	if( rc ){
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_dn2idl: search failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		goto done;
+	}
+
+	if( op->ors_scope == LDAP_SCOPE_CHILDREN ) {
+		cursor->next(cursor);
+	}
+
+	do {
+		rc = cursor->get_key(cursor, &key);
+		if( rc ){
+			Debug( LDAP_DEBUG_ANY,
+				   "wt_dn2idl: get_key failed: %s (%d)\n",
+				   wiredtiger_strerror(rc), rc );
+			goto done;
+		}
+		rc = cursor->get_value(cursor, &id, &pid);
+		if( rc ){
+			Debug( LDAP_DEBUG_ANY,
+				   "wt_dn2id: get_value failed: %s (%d)\n",
+				   wiredtiger_strerror(rc), rc );
+			goto done;
+		}
+
+		if( strncmp(revdn, key, revdn_len) ){
+			break;
+		}
+
+		if( op->ors_scope == LDAP_SCOPE_ONELEVEL && e->e_id != pid ){
+			goto next;
+		}
+		wt_idl_append_one(ids, id);
+	next:
+		rc = cursor->next(cursor);
+	}while(rc == 0);
+
+	if (rc == WT_NOTFOUND ) {
+		rc = LDAP_SUCCESS;
+	}
+
+	wt_idl_sort(ids, stack);
+	Debug( LDAP_DEBUG_TRACE,
+		   "<= wt_dn2idl_db: size=%ld first=%ld last=%ld\n",
+		   (long) ids[0],
+		   (long) WT_IDL_FIRST(ids),
+		   (long) WT_IDL_LAST(ids) );
+
+done:
+	if(revdn){
+		ch_free(revdn);
+	}
+#ifdef WT_CURSOR_CACHE
+	if(cursor){
+		cursor->reset(cursor);
+	}
+#else
+	if(cursor){
+		cursor->close(cursor);
+		wc->dn2id = NULL;
+	}
+#endif
+	return rc;
+}
+
+int
+wt_dn2idl(
+	Operation *op,
+	wt_ctx *wc,
+	struct berval *ndn,
+	Entry *e,
+	ID *ids,
+	ID *stack)
+{
+	struct wt_info *wi = (struct wt_info *) op->o_bd->be_private;
+	int rc;
+
+	Debug( LDAP_DEBUG_TRACE,
+		   "=> wt_dn2idl(\"%s\")\n", ndn->bv_val );
+
+	if(op->ors_scope != LDAP_SCOPE_ONELEVEL &&
+	   be_issuffix( op->o_bd, &e->e_nname )){
+		WT_IDL_ALL(wi, ids);
+		return 0;
+	}
+
+	if (wi->wi_flags & WT_USE_IDLCACHE) {
+		rc = wt_idlcache_get(wc, ndn, op->ors_scope, ids);
+		if (rc == 0) {
+			/* cache hit */
+			return rc;
+		}
+		/* cache miss */
+	}
+
+	if ( wi->wi_flags & WT_USE_IDLCACHE ) {
+		wt_idlcache_begin(wc, ndn, op->ors_scope);
+	}
+	rc = wt_dn2idl_db(op, wc, ndn, e, ids, stack);
+	if ( rc == 0 && wi->wi_flags & WT_USE_IDLCACHE ) {
+		wt_idlcache_set(wc, ndn, op->ors_scope, ids);
+	}
+
+	return rc;
+}
+
+/*
+ * Local variables:
+ * indent-tabs-mode: t
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */
diff --git a/servers/slapd/back-wt/extended.c b/servers/slapd/back-wt/extended.c
new file mode 100644
index 0000000..595672f
--- /dev/null
+++ b/servers/slapd/back-wt/extended.c
@@ -0,0 +1,58 @@
+/* OpenLDAP WiredTiger backend */
+/* $OpenLDAP$ */
+/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
+ *
+ * Copyright 2002-2022 The OpenLDAP Foundation.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted only as authorized by the OpenLDAP
+ * Public License.
+ *
+ * A copy of this license is available in the file LICENSE in the
+ * top-level directory of the distribution or, alternatively, at
+ * <http://www.OpenLDAP.org/license.html>.
+ */
+/* ACKNOWLEDGEMENTS:
+ * This work was developed by HAMANO Tsukasa <hamano@osstech.co.jp>
+ * based on back-bdb for inclusion in OpenLDAP Software.
+ * WiredTiger is a product of MongoDB Inc.
+ */
+
+#include "portable.h"
+
+#include <stdio.h>
+#include <ac/string.h>
+
+#include "back-wt.h"
+#include "lber_pvt.h"
+
+static struct exop {
+	struct berval *oid;
+	BI_op_extended	*extended;
+} exop_table[] = {
+	{ NULL, NULL }
+};
+
+int
+wt_extended( Operation *op, SlapReply *rs )
+{
+	int i;
+
+	for( i=0; exop_table[i].extended != NULL; i++ ) {
+		if( ber_bvcmp( exop_table[i].oid, &op->oq_extended.rs_reqoid ) == 0 ) {
+			return (exop_table[i].extended)( op, rs );
+		}
+	}
+
+	rs->sr_text = "not supported within naming context";
+	return rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
+}
+
+/*
+ * Local variables:
+ * indent-tabs-mode: t
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */
diff --git a/servers/slapd/back-wt/filterindex.c b/servers/slapd/back-wt/filterindex.c
new file mode 100644
index 0000000..f321128
--- /dev/null
+++ b/servers/slapd/back-wt/filterindex.c
@@ -0,0 +1,718 @@
+/* OpenLDAP WiredTiger backend */
+/* $OpenLDAP$ */
+/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
+ *
+ * Copyright 2002-2022 The OpenLDAP Foundation.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted only as authorized by the OpenLDAP
+ * Public License.
+ *
+ * A copy of this license is available in the file LICENSE in the
+ * top-level directory of the distribution or, alternatively, at
+ * <http://www.OpenLDAP.org/license.html>.
+ */
+/* ACKNOWLEDGEMENTS:
+ * This work was developed by HAMANO Tsukasa <hamano@osstech.co.jp>
+ * based on back-bdb for inclusion in OpenLDAP Software.
+ * WiredTiger is a product of MongoDB Inc.
+ */
+
+#include "portable.h"
+
+#include <stdio.h>
+#include <ac/string.h>
+#include "back-wt.h"
+#include "idl.h"
+
+static int
+presence_candidates(
+	Operation *op,
+	wt_ctx *wc,
+	AttributeDescription *desc,
+	ID *ids )
+{
+	struct wt_info *wi = (struct wt_info *) op->o_bd->be_private;
+	slap_mask_t mask;
+	struct berval prefix = {0, NULL};
+	int rc;
+	WT_CURSOR *cursor = NULL;
+
+	Debug( LDAP_DEBUG_TRACE, "=> wt_presence_candidates (%s)\n",
+		   desc->ad_cname.bv_val );
+
+	WT_IDL_ALL( wi, ids );
+
+	if( desc == slap_schema.si_ad_objectClass ) {
+		return 0;
+	}
+
+	rc = wt_index_param( op->o_bd, desc, LDAP_FILTER_PRESENT,
+						 &mask, &prefix );
+
+	if( rc == LDAP_INAPPROPRIATE_MATCHING ) {
+		/* not indexed */
+		Debug( LDAP_DEBUG_FILTER,
+			   "<= wt_presence_candidates: (%s) not indexed\n",
+			   desc->ad_cname.bv_val );
+		return 0;
+	}
+
+	if( rc != LDAP_SUCCESS ) {
+		Debug( LDAP_DEBUG_TRACE,
+			   "<= wt_presence_candidates: (%s) index_param "
+			   "returned=%d\n",
+			   desc->ad_cname.bv_val, rc );
+		return 0;
+	}
+
+	if( prefix.bv_val == NULL ) {
+		Debug( LDAP_DEBUG_TRACE,
+			   "<= wt_presence_candidates: (%s) no prefix\n",
+			   desc->ad_cname.bv_val );
+		return -1;
+	}
+
+	/* open index cursor */
+	cursor = wt_index_open(wc, &desc->ad_type->sat_cname, 0);
+	if( !cursor ) {
+		Debug( LDAP_DEBUG_ANY,
+			   "<= wt_presence_candidates: open index cursor failed: %s\n",
+			   desc->ad_type->sat_cname.bv_val );
+		return 0;
+	}
+
+	rc = wt_key_read( op->o_bd, cursor, &prefix, ids, NULL, 0 );
+
+	cursor->close(cursor);
+	Debug(LDAP_DEBUG_TRACE,
+		  "<= wt_presence_candidates: id=%ld first=%ld last=%ld\n",
+		  (long) ids[0],
+		  (long) WT_IDL_FIRST(ids),
+		  (long) WT_IDL_LAST(ids) );
+
+	return 0;
+}
+
+static int
+equality_candidates(
+	Operation *op,
+	wt_ctx *wc,
+	AttributeAssertion *ava,
+	ID *ids,
+	ID *tmp)
+{
+	struct wt_info *wi = (struct wt_info *) op->o_bd->be_private;
+	slap_mask_t mask;
+	struct berval prefix = {0, NULL};
+	struct berval *keys = NULL;
+	int i;
+	int rc;
+	MatchingRule *mr;
+	WT_CURSOR *cursor = NULL;
+
+	Debug( LDAP_DEBUG_TRACE, "=> wt_equality_candidates (%s=%s)\n",
+		   ava->aa_desc->ad_cname.bv_val, ava->aa_value.bv_val );
+
+	if ( ava->aa_desc == slap_schema.si_ad_entryDN ) {
+		ID id = NOID;
+		rc = wt_dn2id(op, wc, &ava->aa_value, &id);
+		if( rc == 0 ){
+			wt_idl_append_one(ids, id);
+		}else if ( rc == WT_NOTFOUND ) {
+			WT_IDL_ZERO( ids );
+			rc = 0;
+		}
+		return rc;
+	}
+
+	WT_IDL_ALL( wi, ids );
+
+	rc = wt_index_param( op->o_bd, ava->aa_desc, LDAP_FILTER_EQUALITY,
+						 &mask, &prefix );
+
+	if ( rc == LDAP_INAPPROPRIATE_MATCHING ) {
+		Debug( LDAP_DEBUG_FILTER,
+			   "<= wt_equality_candidates: (%s) not indexed\n",
+			   ava->aa_desc->ad_cname.bv_val );
+		return 0;
+	}
+
+	if( rc != LDAP_SUCCESS ) {
+		Debug( LDAP_DEBUG_ANY,
+			   "<= wt_equality_candidates: (%s) index_param failed (%d)\n",
+			   ava->aa_desc->ad_cname.bv_val, rc );
+		return 0;
+	}
+
+	mr = ava->aa_desc->ad_type->sat_equality;
+	if( !mr ) {
+		return 0;
+	}
+
+	if( !mr->smr_filter ) {
+		return 0;
+	}
+
+	rc = (mr->smr_filter)(
+		LDAP_FILTER_EQUALITY,
+		mask,
+		ava->aa_desc->ad_type->sat_syntax,
+		mr,
+		&prefix,
+		&ava->aa_value,
+		&keys, op->o_tmpmemctx );
+
+	if( rc != LDAP_SUCCESS ) {
+		Debug( LDAP_DEBUG_TRACE,
+			   "<= wt_equality_candidates: (%s, %s) "
+			   "MR filter failed (%d)\n",
+			   prefix.bv_val, ava->aa_desc->ad_cname.bv_val, rc );
+		return 0;
+	}
+
+	if( keys == NULL ) {
+		Debug( LDAP_DEBUG_TRACE,
+			   "<= wt_equality_candidates: (%s) no keys\n",
+			   ava->aa_desc->ad_cname.bv_val );
+		return 0;
+	}
+
+	/* open index cursor */
+	cursor = wt_index_open(wc, &ava->aa_desc->ad_type->sat_cname, 0);
+	if( !cursor ) {
+		Debug( LDAP_DEBUG_ANY,
+			   "<= wt_equality_candidates: open index cursor failed: %s\n",
+			   ava->aa_desc->ad_type->sat_cname.bv_val );
+		return 0;
+	}
+
+	for ( i= 0; keys[i].bv_val != NULL; i++ ) {
+		rc = wt_key_read( op->o_bd, cursor, &keys[i], tmp, NULL, 0 );
+		if( rc == WT_NOTFOUND ) {
+			WT_IDL_ZERO( ids );
+			rc = 0;
+			break;
+		} else if( rc != LDAP_SUCCESS ) {
+			Debug( LDAP_DEBUG_TRACE,
+				   "<= wt_equality_candidates: (%s) key read failed (%d)\n",
+				   ava->aa_desc->ad_cname.bv_val, rc );
+			break;
+		}
+		if ( i == 0 ) {
+			WT_IDL_CPY( ids, tmp );
+		} else {
+			wt_idl_intersection( ids, tmp );
+		}
+
+		if( WT_IDL_IS_ZERO( ids ) )
+			break;
+	}
+
+	ber_bvarray_free_x( keys, op->o_tmpmemctx );
+
+	cursor->close(cursor);
+
+	Debug( LDAP_DEBUG_TRACE,
+		   "<= wt_equality_candidates: id=%ld, first=%ld, last=%ld\n",
+		   (long) ids[0],
+		   (long) WT_IDL_FIRST(ids),
+		   (long) WT_IDL_LAST(ids) );
+
+	return rc;
+}
+
+static int
+approx_candidates(
+	Operation *op,
+	wt_ctx *wc,
+	AttributeAssertion *ava,
+	ID *ids,
+	ID *tmp )
+{
+	struct wt_info *wi = (struct wt_info *) op->o_bd->be_private;
+	int i;
+	int rc;
+    slap_mask_t mask;
+	struct berval prefix = {0, NULL};
+	struct berval *keys = NULL;
+	MatchingRule *mr;
+	WT_CURSOR *cursor = NULL;
+
+	Debug( LDAP_DEBUG_TRACE, "=> wt_approx_candidates (%s)\n",
+		   ava->aa_desc->ad_cname.bv_val );
+
+	WT_IDL_ALL( wi, ids );
+
+	rc = wt_index_param( op->o_bd, ava->aa_desc, LDAP_FILTER_APPROX,
+						 &mask, &prefix );
+
+	if ( rc == LDAP_INAPPROPRIATE_MATCHING ) {
+		Debug( LDAP_DEBUG_FILTER,
+			   "<= wt_approx_candidates: (%s) not indexed\n",
+			   ava->aa_desc->ad_cname.bv_val );
+		return 0;
+	}
+
+	if( rc != LDAP_SUCCESS ) {
+		Debug( LDAP_DEBUG_ANY,
+			   "<= wt_approx_candidates: (%s) index_param failed (%d)\n",
+			   ava->aa_desc->ad_cname.bv_val, rc );
+		return 0;
+	}
+
+	mr = ava->aa_desc->ad_type->sat_approx;
+	if( !mr ) {
+		/* no approx matching rule, try equality matching rule */
+		mr = ava->aa_desc->ad_type->sat_equality;
+	}
+
+	if( !mr ) {
+		return 0;
+	}
+
+	if( !mr->smr_filter ) {
+		return 0;
+	}
+
+	rc = (mr->smr_filter)(
+		LDAP_FILTER_APPROX,
+		mask,
+		ava->aa_desc->ad_type->sat_syntax,
+		mr,
+		&prefix,
+		&ava->aa_value,
+		&keys, op->o_tmpmemctx );
+
+	if( rc != LDAP_SUCCESS ) {
+		Debug( LDAP_DEBUG_TRACE,
+			   "<= wt_approx_candidates: (%s, %s) MR filter failed (%d)\n",
+			   prefix.bv_val, ava->aa_desc->ad_cname.bv_val, rc );
+		return 0;
+	}
+
+	if( keys == NULL ) {
+		Debug( LDAP_DEBUG_TRACE,
+			   "<= wt_approx_candidates: (%s) no keys (%s)\n",
+			   prefix.bv_val, ava->aa_desc->ad_cname.bv_val );
+		return 0;
+	}
+
+	/* open index cursor */
+	cursor = wt_index_open(wc, &ava->aa_desc->ad_type->sat_cname, 0);
+	if( !cursor ) {
+		Debug( LDAP_DEBUG_ANY,
+			   "<= wt_approx_candidates: open index cursor failed: %s\n",
+			   ava->aa_desc->ad_type->sat_cname.bv_val );
+		return 0;
+	}
+
+	for ( i= 0; keys[i].bv_val != NULL; i++ ) {
+		rc = wt_key_read( op->o_bd, cursor, &keys[i], tmp, NULL, 0 );
+		if( rc == WT_NOTFOUND ) {
+			WT_IDL_ZERO( ids );
+			rc = 0;
+			break;
+		} else if( rc != LDAP_SUCCESS ) {
+			Debug( LDAP_DEBUG_TRACE,
+				   "<= wt_approx_candidates: (%s) key read failed (%d)\n",
+				   ava->aa_desc->ad_cname.bv_val, rc );
+			break;
+		}
+
+		if( WT_IDL_IS_ZERO( tmp ) ) {
+			Debug( LDAP_DEBUG_TRACE,
+				   "<= wt_approx_candidates: (%s) NULL\n",
+				   ava->aa_desc->ad_cname.bv_val );
+			WT_IDL_ZERO( ids );
+			break;
+		}
+
+		if ( i == 0 ) {
+			WT_IDL_CPY( ids, tmp );
+		} else {
+			wt_idl_intersection( ids, tmp );
+		}
+
+		if( WT_IDL_IS_ZERO( ids ) )
+			break;
+	}
+
+	ber_bvarray_free_x( keys, op->o_tmpmemctx );
+
+	cursor->close(cursor);
+
+	Debug( LDAP_DEBUG_TRACE,
+		   "<= wt_approx_candidates %ld, first=%ld, last=%ld\n",
+		   (long) ids[0],
+		   (long) WT_IDL_FIRST(ids),
+		   (long) WT_IDL_LAST(ids) );
+
+	return rc;
+}
+
+static int
+substring_candidates(
+	Operation *op,
+	wt_ctx *wc,
+	SubstringsAssertion *sub,
+	ID *ids,
+	ID *tmp )
+{
+	struct wt_info *wi = (struct wt_info *) op->o_bd->be_private;
+	int i;
+	int rc;
+    slap_mask_t mask;
+	struct berval prefix = {0, NULL};
+	struct berval *keys = NULL;
+	MatchingRule *mr;
+	WT_CURSOR *cursor = NULL;
+
+	Debug( LDAP_DEBUG_TRACE, "=> wt_substring_candidates (%s)\n",
+		   sub->sa_desc->ad_cname.bv_val );
+
+	WT_IDL_ALL( wi, ids );
+
+	rc = wt_index_param( op->o_bd, sub->sa_desc, LDAP_FILTER_SUBSTRINGS,
+						 &mask, &prefix );
+
+	if ( rc == LDAP_INAPPROPRIATE_MATCHING ) {
+		Debug( LDAP_DEBUG_FILTER,
+			   "<= wt_substring_candidates: (%s) not indexed\n",
+			   sub->sa_desc->ad_cname.bv_val );
+		return 0;
+	}
+
+	if( rc != LDAP_SUCCESS ) {
+		Debug( LDAP_DEBUG_ANY,
+			   "<= wt_substring_candidates: (%s) index_param failed (%d)\n",
+			   sub->sa_desc->ad_cname.bv_val, rc );
+		return 0;
+	}
+
+	mr = sub->sa_desc->ad_type->sat_substr;
+
+	if( !mr ) {
+		return 0;
+	}
+
+	if( !mr->smr_filter ) {
+		return 0;
+	}
+
+	rc = (mr->smr_filter)(
+		LDAP_FILTER_SUBSTRINGS,
+		mask,
+		sub->sa_desc->ad_type->sat_syntax,
+		mr,
+		&prefix,
+		sub,
+		&keys, op->o_tmpmemctx );
+
+	if( rc != LDAP_SUCCESS ) {
+		Debug( LDAP_DEBUG_TRACE,
+			   "<= wt_substring_candidates: (%s) MR filter failed (%d)\n",
+			   sub->sa_desc->ad_cname.bv_val, rc );
+		return 0;
+	}
+
+	if( keys == NULL ) {
+		Debug( LDAP_DEBUG_TRACE,
+			   "<= wt_substring_candidates: (0x%04lx) no keys (%s)\n",
+			   mask, sub->sa_desc->ad_cname.bv_val );
+		return 0;
+	}
+
+	/* open index cursor */
+	cursor = wt_index_open(wc, &sub->sa_desc->ad_cname, 0);
+	if( !cursor ) {
+		Debug( LDAP_DEBUG_ANY,
+			   "<= wt_substring_candidates: open index cursor failed: %s\n",
+			   sub->sa_desc->ad_cname.bv_val );
+		return 0;
+	}
+
+	for ( i= 0; keys[i].bv_val != NULL; i++ ) {
+		rc = wt_key_read( op->o_bd, cursor, &keys[i], tmp, NULL, 0 );
+
+		if( rc == WT_NOTFOUND ) {
+			WT_IDL_ZERO( ids );
+			rc = 0;
+			break;
+		} else if( rc != LDAP_SUCCESS ) {
+			Debug( LDAP_DEBUG_TRACE,
+				   "<= wt_substring_candidates: (%s) key read failed (%d)\n",
+				   sub->sa_desc->ad_cname.bv_val, rc );
+			break;
+		}
+
+		if( WT_IDL_IS_ZERO( tmp ) ) {
+			Debug( LDAP_DEBUG_TRACE,
+				   "<= wt_substring_candidates: (%s) NULL\n",
+				   sub->sa_desc->ad_cname.bv_val );
+			WT_IDL_ZERO( ids );
+			break;
+		}
+
+		if ( i == 0 ) {
+			WT_IDL_CPY( ids, tmp );
+		} else {
+			wt_idl_intersection( ids, tmp );
+		}
+
+		if( WT_IDL_IS_ZERO( ids ) )
+			break;
+	}
+
+	ber_bvarray_free_x( keys, op->o_tmpmemctx );
+
+	cursor->close(cursor);
+
+	Debug( LDAP_DEBUG_TRACE,
+		   "<= wt_substring_candidates: %ld, first=%ld, last=%ld\n",
+		   (long) ids[0],
+		   (long) WT_IDL_FIRST(ids),
+		   (long) WT_IDL_LAST(ids));
+	return rc;
+}
+
+#ifdef LDAP_COMP_MATCH
+static int
+comp_candidates (
+	Operation *op,
+	wt_ctx *wc,
+	MatchingRuleAssertion *mra,
+	ComponentFilter *f,
+	ID *ids,
+	ID *tmp,
+	ID *stack)
+{
+	int	rc = 0;
+
+	if ( !f ) return LDAP_PROTOCOL_ERROR;
+
+	Debug( LDAP_DEBUG_FILTER, "comp_candidates\n" );
+	/* TODO: */
+	Debug( LDAP_DEBUG_FILTER, "=> not implement yet\n" );
+	return( rc );
+}
+
+#endif
+
+static int
+ext_candidates(
+	Operation *op,
+	wt_ctx *wc,
+	MatchingRuleAssertion *mra,
+	ID *ids,
+	ID *tmp,
+	ID *stack )
+{
+	struct wt_info *wi = (struct wt_info *) op->o_bd->be_private;
+
+#ifdef LDAP_COMP_MATCH
+	/*
+	 * Currently Only Component Indexing for componentFilterMatch is supported
+	 * Indexing for an extensible filter is not supported yet
+	 */
+	if ( mra->ma_cf ) {
+		return comp_candidates ( op, wc, mra, mra->ma_cf, ids, tmp, stack);
+	}
+#endif
+	if ( mra->ma_desc == slap_schema.si_ad_entryDN ) {
+		/* TODO: */
+		Debug( LDAP_DEBUG_FILTER, "=> not implement yet.\n" );
+	}
+	WT_IDL_ALL( wi, ids );
+	return 0;
+}
+
+static int
+list_candidates(
+	Operation *op,
+	wt_ctx *wc,
+	Filter *flist,
+	int ftype,
+	ID *ids,
+	ID *tmp,
+	ID *save )
+{
+	int rc = 0;
+	Filter  *f;
+
+	Debug( LDAP_DEBUG_FILTER, "=> wt_list_candidates 0x%x\n", ftype );
+	for ( f = flist; f != NULL; f = f->f_next ) {
+		/* ignore precomputed scopes */
+		if ( f->f_choice == SLAPD_FILTER_COMPUTED &&
+			 f->f_result == LDAP_SUCCESS ) {
+			continue;
+		}
+		WT_IDL_ZERO( save );
+		rc = wt_filter_candidates( op, wc, f, save, tmp,
+								   save+WT_IDL_UM_SIZE );
+
+		if ( rc != 0 ) {
+			/* TODO: error handling */
+			/*
+			if ( rc == DB_LOCK_DEADLOCK )
+				return rc;
+			*/
+			if ( ftype == LDAP_FILTER_AND ) {
+				rc = 0;
+				continue;
+			}
+			break;
+		}
+
+
+		if ( ftype == LDAP_FILTER_AND ) {
+			if ( f == flist ) {
+				WT_IDL_CPY( ids, save );
+			} else {
+				wt_idl_intersection( ids, save );
+			}
+			if( WT_IDL_IS_ZERO( ids ) )
+				break;
+		} else {
+			if ( f == flist ) {
+				WT_IDL_CPY( ids, save );
+			} else {
+				wt_idl_union( ids, save );
+			}
+		}
+	}
+
+	if( rc == LDAP_SUCCESS ) {
+		Debug( LDAP_DEBUG_FILTER,
+			   "<= wt_list_candidates: id=%ld first=%ld last=%ld\n",
+			   (long) ids[0],
+			   (long) WT_IDL_FIRST(ids),
+			   (long) WT_IDL_LAST(ids) );
+
+	} else {
+		Debug( LDAP_DEBUG_FILTER,
+			   "<= wt_list_candidates: undefined rc=%d\n",
+			   rc );
+	}
+
+	return 0;
+}
+
+int
+wt_filter_candidates(
+	Operation *op,
+	wt_ctx *wc,
+	Filter *f,
+	ID *ids,
+	ID *tmp,
+	ID *stack )
+{
+	struct wt_info *wi = (struct wt_info *)op->o_bd->be_private;
+	int rc = LDAP_SUCCESS;
+	Debug( LDAP_DEBUG_FILTER, "=> wt_filter_candidates\n" );
+
+	if ( f->f_choice & SLAPD_FILTER_UNDEFINED ) {
+		WT_IDL_ZERO( ids );
+		goto done;
+	}
+
+	switch ( f->f_choice ) {
+	case SLAPD_FILTER_COMPUTED:
+		switch( f->f_result ) {
+		case SLAPD_COMPARE_UNDEFINED:
+			/* This technically is not the same as FALSE, but it
+			 * certainly will produce no matches.
+			 */
+			/* FALL THRU */
+		case LDAP_COMPARE_FALSE:
+			WT_IDL_ZERO( ids );
+			break;
+		case LDAP_COMPARE_TRUE: {
+
+			WT_IDL_ALL( wi, ids );
+		} break;
+		case LDAP_SUCCESS:
+			/* this is a pre-computed scope, leave it alone */
+			break;
+		}
+		break;
+	case LDAP_FILTER_PRESENT:
+		Debug( LDAP_DEBUG_FILTER, "\tPRESENT\n" );
+		rc = presence_candidates( op, wc, f->f_desc, ids );
+		break;
+
+	case LDAP_FILTER_EQUALITY:
+		Debug( LDAP_DEBUG_FILTER, "\tEQUALITY\n" );
+		rc = equality_candidates( op, wc, f->f_ava, ids, tmp );
+		break;
+
+	case LDAP_FILTER_APPROX:
+		Debug( LDAP_DEBUG_FILTER, "\tAPPROX\n" );
+		rc = approx_candidates( op, wc, f->f_ava, ids, tmp );
+		break;
+
+	case LDAP_FILTER_SUBSTRINGS:
+		Debug( LDAP_DEBUG_FILTER, "\tSUBSTRINGS\n" );
+		rc = substring_candidates( op, wc, f->f_sub, ids, tmp );
+		break;
+
+	case LDAP_FILTER_GE:
+		/* if no GE index, use pres */
+		/* TODO: not implement yet */
+		rc = presence_candidates( op, wc, f->f_ava->aa_desc, ids );
+		break;
+
+    case LDAP_FILTER_LE:
+		/* if no LE index, use pres */
+		/* TODO: not implement yet */
+		Debug( LDAP_DEBUG_FILTER, "\tLE\n" );
+		rc = presence_candidates( op, wc, f->f_ava->aa_desc, ids );
+		break;
+
+	case LDAP_FILTER_NOT:
+		/* no indexing to support NOT filters */
+		Debug( LDAP_DEBUG_FILTER, "\tNOT\n" );
+		WT_IDL_ALL( wi, ids );
+		break;
+
+	case LDAP_FILTER_AND:
+		Debug( LDAP_DEBUG_FILTER, "\tAND\n" );
+		rc = list_candidates( op, wc,
+							  f->f_and, LDAP_FILTER_AND, ids, tmp, stack );
+		break;
+
+	case LDAP_FILTER_OR:
+		Debug( LDAP_DEBUG_FILTER, "\tOR\n" );
+		rc = list_candidates( op, wc,
+							  f->f_or, LDAP_FILTER_OR, ids, tmp, stack );
+		break;
+
+	case LDAP_FILTER_EXT:
+		Debug( LDAP_DEBUG_FILTER, "\tEXT\n" );
+		rc = ext_candidates( op, wc, f->f_mra, ids, tmp, stack);
+		break;
+
+	default:
+		Debug( LDAP_DEBUG_FILTER, "\tUNKNOWN %lu\n",
+			   (unsigned long) f->f_choice );
+		/* Must not return NULL, otherwise extended filters break */
+		WT_IDL_ALL( wi, ids );
+	}
+
+done:
+	Debug( LDAP_DEBUG_FILTER,
+		   "<= wt_filter_candidates: id=%ld first=%ld last=%ld\n",
+		   (long) ids[0],
+		   (long) WT_IDL_FIRST( ids ),
+		   (long) WT_IDL_LAST( ids ) );
+	return rc;
+}
+
+/*
+ * Local variables:
+ * indent-tabs-mode: t
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */
diff --git a/servers/slapd/back-wt/id2entry.c b/servers/slapd/back-wt/id2entry.c
new file mode 100644
index 0000000..95b197c
--- /dev/null
+++ b/servers/slapd/back-wt/id2entry.c
@@ -0,0 +1,352 @@
+/* OpenLDAP WiredTiger backend */
+/* $OpenLDAP$ */
+/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
+ *
+ * Copyright 2002-2022 The OpenLDAP Foundation.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted only as authorized by the OpenLDAP
+ * Public License.
+ *
+ * A copy of this license is available in the file LICENSE in the
+ * top-level directory of the distribution or, alternatively, at
+ * <http://www.OpenLDAP.org/license.html>.
+ */
+/* ACKNOWLEDGEMENTS:
+ * This work was developed by HAMANO Tsukasa <hamano@osstech.co.jp>
+ * based on back-bdb for inclusion in OpenLDAP Software.
+ * WiredTiger is a product of MongoDB Inc.
+ */
+
+#include "back-wt.h"
+#include "slap-config.h"
+
+static int wt_id2entry_put(
+	Operation *op,
+	wt_ctx *wc,
+	Entry *e,
+	WT_CURSOR *cursor)
+{
+	struct berval bv;
+	WT_ITEM item;
+	int rc;
+
+	rc = entry_encode( e, &bv );
+	if(rc != LDAP_SUCCESS){
+		return -1;
+	}
+	item.size = bv.bv_len;
+	item.data = bv.bv_val;
+
+	cursor->set_key(cursor, e->e_id);
+	cursor->set_value(cursor, e->e_ndn, &item);
+	rc = cursor->insert(cursor);
+	if ( rc ) {
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_id2entry_put: insert failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		goto done;
+	}
+
+done:
+	ch_free( bv.bv_val );
+
+	return rc;
+}
+
+int wt_id2entry_add(
+	Operation *op,
+	wt_ctx *wc,
+	Entry *e )
+{
+	WT_SESSION *session = wc->session;
+	WT_CURSOR *cursor = wc->id2entry_add;
+	int rc;
+
+	if(!cursor){
+		rc = session->open_cursor(session, WT_TABLE_ID2ENTRY, NULL,
+								  "overwrite=false", &cursor);
+		if ( rc ) {
+			Debug( LDAP_DEBUG_ANY,
+				   "wt_id2entry_put: open_cursor failed: %s (%d)\n",
+				   wiredtiger_strerror(rc), rc );
+			return rc;
+		}
+		wc->id2entry_add = cursor;
+	}
+
+	rc = wt_id2entry_put(op, wc, e, cursor);
+
+#ifdef WT_CURSOR_CACHE
+	if(cursor){
+		cursor->reset(cursor);
+	}
+#else
+	if(cursor){
+		cursor->close(cursor);
+		wc->id2entry_add = NULL;
+	}
+#endif
+
+	return rc;
+}
+
+int wt_id2entry_update(
+	Operation *op,
+	wt_ctx *wc,
+	Entry *e )
+{
+	WT_SESSION *session = wc->session;
+	WT_CURSOR *cursor = wc->id2entry_update;
+	int rc;
+
+	if(!cursor){
+		rc = session->open_cursor(session, WT_TABLE_ID2ENTRY, NULL,
+								  "overwrite=true", &cursor);
+		if ( rc ) {
+			Debug( LDAP_DEBUG_ANY,
+				   "wt_id2entry_put: open_cursor failed: %s (%d)\n",
+				   wiredtiger_strerror(rc), rc );
+			return rc;
+		}
+		wc->id2entry_update = cursor;
+	}
+	rc = wt_id2entry_put(op, wc, e, cursor);
+
+#ifdef WT_CURSOR_CACHE
+	if(cursor){
+		cursor->reset(cursor);
+	}
+#else
+	if(cursor){
+		cursor->close(cursor);
+		wc->id2entry_update = NULL;
+	}
+#endif
+	return rc;
+}
+
+int wt_id2entry_delete(
+	Operation *op,
+	wt_ctx *wc,
+	Entry *e )
+{
+	int rc;
+	WT_SESSION *session = wc->session;
+	WT_CURSOR *cursor = NULL;
+
+	rc = session->open_cursor(session, WT_TABLE_ID2ENTRY, NULL,
+							  NULL, &cursor);
+	if ( rc ) {
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_id2entry_delete: open_cursor failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		goto done;
+	}
+	cursor->set_key(cursor, e->e_id);
+	rc = cursor->remove(cursor);
+	if ( rc ) {
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_id2entry_delete: remove failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		goto done;
+	}
+
+done:
+	if(cursor){
+		cursor->close(cursor);
+	}
+	return rc;
+}
+
+int wt_id2entry( BackendDB *be,
+				 wt_ctx *wc,
+				 ID id,
+				 Entry **ep ){
+	int rc;
+	WT_SESSION *session = wc->session;
+	WT_CURSOR *cursor = wc->id2entry;
+	WT_ITEM item;
+	EntryHeader eh;
+	int eoff;
+	Entry *e = NULL;
+
+	if(!cursor){
+		rc = session->open_cursor(session, WT_TABLE_ID2ENTRY"(entry)", NULL,
+								  NULL, &cursor);
+		if ( rc ) {
+			Debug( LDAP_DEBUG_ANY,
+				   "wt_id2entry: open_cursor failed: %s (%d)\n",
+				   wiredtiger_strerror(rc), rc );
+			goto done;
+		}
+		wc->id2entry = cursor;
+	}
+
+	cursor->set_key(cursor, id);
+	rc = cursor->search(cursor);
+	if ( rc ) {
+		goto done;
+	}
+
+	cursor->get_value(cursor, &item);
+	rc = wt_entry_header( &item,  &eh );
+	eoff = eh.data - (char *)item.data;
+	eh.bv.bv_len = eh.nvals * sizeof( struct berval ) + item.size;
+	eh.bv.bv_val = ch_malloc( eh.bv.bv_len );
+	memset(eh.bv.bv_val, 0xff, eh.bv.bv_len);
+	eh.data = eh.bv.bv_val + eh.nvals * sizeof( struct berval );
+	memcpy(eh.data, item.data, item.size);
+	eh.data += eoff;
+	rc = entry_decode( &eh, &e );
+	if ( rc ) {
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_id2entry: entry decode error: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		goto done;
+	}
+	e->e_id = id;
+	*ep = e;
+
+done:
+
+#ifdef WT_CURSOR_CACHE
+	if(cursor){
+		cursor->reset(cursor);
+	}
+#else
+	if(cursor){
+		cursor->close(cursor);
+		wc->id2entry = NULL;
+	}
+#endif
+	return rc;
+}
+
+int wt_entry_return(
+	Entry *e
+	)
+{
+	if ( !e ) {
+		return 0;
+	}
+
+    /* Our entries are allocated in two blocks; the data comes from
+	 * the db itself and the Entry structure and associated pointers
+	 * are allocated in entry_decode. The db data pointer is saved
+	 * in e_bv.
+	 */
+	if ( e->e_bv.bv_val ) {
+#if 0
+		/* See if the DNs were changed by modrdn */
+		if( e->e_nname.bv_val < e->e_bv.bv_val || e->e_nname.bv_val >
+			e->e_bv.bv_val + e->e_bv.bv_len ) {
+			ch_free(e->e_name.bv_val);
+			ch_free(e->e_nname.bv_val);
+		}
+#endif
+		e->e_name.bv_val = NULL;
+		e->e_nname.bv_val = NULL;
+		/* In tool mode the e_bv buffer is realloc'd, leave it alone */
+		if( !(slapMode & SLAP_TOOL_MODE) ) {
+			free( e->e_bv.bv_val );
+		}
+		BER_BVZERO( &e->e_bv );
+	}
+
+	entry_free( e );
+}
+
+int wt_entry_release(
+	Operation *op,
+	Entry *e,
+	int rw )
+{
+	return wt_entry_return( e );
+}
+
+/*
+ * return LDAP_SUCCESS IFF we can retrieve the specified entry.
+ */
+int wt_entry_get(
+	Operation *op,
+	struct berval *ndn,
+	ObjectClass *oc,
+	AttributeDescription *at,
+	int rw,
+	Entry **ent )
+{
+	struct wt_info *wi = (struct wt_info *) op->o_bd->be_private;
+	wt_ctx *wc;
+	Entry *e = NULL;
+	int	rc;
+	const char *at_name = at ? at->ad_cname.bv_val : "(null)";
+
+	Debug( LDAP_DEBUG_ARGS,
+		   "wt_entry_get: ndn: \"%s\"\n", ndn->bv_val );
+	Debug( LDAP_DEBUG_ARGS,
+		   "wt_entry_get: oc: \"%s\", at: \"%s\"\n",
+		   oc ? oc->soc_cname.bv_val : "(null)", at_name );
+
+	wc = wt_ctx_get(op, wi);
+	if( !wc ){
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_entry_get: wt_ctx_get failed\n" );
+		return LDAP_OTHER;
+	}
+	rc = wt_dn2entry(op->o_bd, wc, ndn, &e);
+	switch( rc ) {
+	case 0:
+		break;
+	case WT_NOTFOUND:
+		Debug( LDAP_DEBUG_ACL,
+			   "wt_entry_get: cannot find entry: \"%s\"\n",
+			   ndn->bv_val );
+		return LDAP_NO_SUCH_OBJECT;
+	default:
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_entry_get: wt_dn2entry failed %s rc=%d\n",
+			   wiredtiger_strerror(rc), rc );
+		rc = LDAP_OTHER;
+	}
+
+	Debug( LDAP_DEBUG_ACL,
+		   "wt_entry_get: found entry: \"%s\"\n", ndn->bv_val );
+
+	if ( oc && !is_entry_objectclass( e, oc, 0 )) {
+		Debug( LDAP_DEBUG_ACL,
+			   "wt_entry_get: failed to find objectClass %s\n",
+			   oc->soc_cname.bv_val );
+		rc = LDAP_NO_SUCH_ATTRIBUTE;
+		goto return_results;
+	}
+
+	/* NOTE: attr_find() or attrs_find()? */
+	if ( at && attr_find( e->e_attrs, at ) == NULL ) {
+		Debug( LDAP_DEBUG_ACL,
+			   "wt_entry_get: failed to find attribute %s\n",
+			   at->ad_cname.bv_val );
+		rc = LDAP_NO_SUCH_ATTRIBUTE;
+		goto return_results;
+	}
+
+return_results:
+	if( rc != LDAP_SUCCESS ) {
+		wt_entry_return( e );
+	}else{
+		*ent = e;
+	}
+
+	Debug( LDAP_DEBUG_TRACE, "wt_entry_get: rc=%d\n", rc );
+
+	return rc;
+}
+
+/*
+ * Local variables:
+ * indent-tabs-mode: t
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */
diff --git a/servers/slapd/back-wt/idl.c b/servers/slapd/back-wt/idl.c
new file mode 100644
index 0000000..0f3167d
--- /dev/null
+++ b/servers/slapd/back-wt/idl.c
@@ -0,0 +1,789 @@
+/* OpenLDAP WiredTiger backend */
+/* $OpenLDAP$ */
+/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
+ *
+ * Copyright 2002-2022 The OpenLDAP Foundation.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted only as authorized by the OpenLDAP
+ * Public License.
+ *
+ * A copy of this license is available in the file LICENSE in the
+ * top-level directory of the distribution or, alternatively, at
+ * <http://www.OpenLDAP.org/license.html>.
+ */
+/* ACKNOWLEDGEMENTS:
+ * This work was developed by HAMANO Tsukasa <hamano@osstech.co.jp>
+ * based on back-bdb for inclusion in OpenLDAP Software.
+ * WiredTiger is a product of MongoDB Inc.
+ */
+
+#include "portable.h"
+
+#include <stdio.h>
+#include <ac/string.h>
+
+#include "back-wt.h"
+#include "idl.h"
+
+#define IDL_MAX(x,y)	( (x) > (y) ? (x) : (y) )
+#define IDL_MIN(x,y)	( (x) < (y) ? (x) : (y) )
+#define IDL_CMP(x,y)	( (x) < (y) ? -1 : (x) > (y) )
+
+void wt_idl_check( ID *ids )
+{
+	if( WT_IDL_IS_RANGE( ids ) ) {
+		assert( WT_IDL_RANGE_FIRST(ids) <= WT_IDL_RANGE_LAST(ids) );
+	} else {
+		ID i;
+		for( i=1; i < ids[0]; i++ ) {
+			assert( ids[i+1] > ids[i] );
+		}
+	}
+}
+
+void wt_idl_dump( ID *ids )
+{
+	if( WT_IDL_IS_RANGE( ids ) ) {
+		Debug( LDAP_DEBUG_ANY,
+               "IDL: range ( %ld - %ld )\n",
+               (long) WT_IDL_RANGE_FIRST( ids ),
+               (long) WT_IDL_RANGE_LAST( ids ) );
+
+	} else {
+		ID i;
+		Debug( LDAP_DEBUG_ANY, "IDL: size %ld", (long) ids[0] );
+
+		for( i=1; i<=ids[0]; i++ ) {
+			if( i % 16 == 1 ) {
+				Debug( LDAP_DEBUG_ANY, "\n" );
+			}
+			Debug( LDAP_DEBUG_ANY, "  %02lx", (long) ids[i] );
+		}
+
+		Debug( LDAP_DEBUG_ANY, "\n" );
+	}
+
+	wt_idl_check( ids );
+}
+
+unsigned wt_idl_search( ID *ids, ID id )
+{
+#define IDL_BINARY_SEARCH 1
+#ifdef IDL_BINARY_SEARCH
+	/*
+	 * binary search of id in ids
+	 * if found, returns position of id
+	 * if not found, returns first position greater than id
+	 */
+	unsigned base = 0;
+	unsigned cursor = 1;
+	int val = 0;
+	unsigned n = ids[0];
+
+#if IDL_DEBUG > 0
+	idl_check( ids );
+#endif
+
+	while( 0 < n ) {
+		unsigned pivot = n >> 1;
+		cursor = base + pivot + 1;
+		val = IDL_CMP( id, ids[cursor] );
+
+		if( val < 0 ) {
+			n = pivot;
+
+		} else if ( val > 0 ) {
+			base = cursor;
+			n -= pivot + 1;
+
+		} else {
+			return cursor;
+		}
+	}
+
+	if( val > 0 ) {
+		++cursor;
+	}
+	return cursor;
+
+#else
+	/* (reverse) linear search */
+	int i;
+
+#if IDL_DEBUG > 0
+	idl_check( ids );
+#endif
+
+	for( i=ids[0]; i; i-- ) {
+		if( id > ids[i] ) {
+			break;
+		}
+	}
+
+	return i+1;
+#endif
+}
+
+int wt_idl_insert( ID *ids, ID id )
+{
+	unsigned x;
+
+#if IDL_DEBUG > 1
+	Debug( LDAP_DEBUG_ANY, "insert: %04lx at %d\n", (long) id, x );
+	idl_dump( ids );
+#elif IDL_DEBUG > 0
+	wt_idl_check( ids );
+#endif
+
+	if (WT_IDL_IS_RANGE( ids )) {
+		/* if already in range, treat as a dup */
+		if (id >= WT_IDL_RANGE_FIRST(ids) && id <= WT_IDL_RANGE_LAST(ids))
+			return -1;
+		if (id < WT_IDL_RANGE_FIRST(ids))
+			ids[1] = id;
+		else if (id > WT_IDL_RANGE_LAST(ids))
+			ids[2] = id;
+		return 0;
+	}
+
+	x = wt_idl_search( ids, id );
+	assert( x > 0 );
+
+	if( x < 1 ) {
+		/* internal error */
+		return -2;
+	}
+
+	if ( x <= ids[0] && ids[x] == id ) {
+		/* duplicate */
+		return -1;
+	}
+
+	if ( ++ids[0] >= WT_IDL_DB_MAX ) {
+		if( id < ids[1] ) {
+			ids[1] = id;
+			ids[2] = ids[ids[0]-1];
+		} else if ( ids[ids[0]-1] < id ) {
+			ids[2] = id;
+		} else {
+			ids[2] = ids[ids[0]-1];
+		}
+		ids[0] = NOID;
+
+	} else {
+		/* insert id */
+		AC_MEMCPY( &ids[x+1], &ids[x], (ids[0]-x) * sizeof(ID) );
+		ids[x] = id;
+	}
+
+#if IDL_DEBUG > 1
+	wt_idl_dump( ids );
+#elif IDL_DEBUG > 0
+	wt_idl_check( ids );
+#endif
+
+	return 0;
+}
+
+static int wt_idl_delete( ID *ids, ID id )
+{
+	unsigned x;
+
+#if IDL_DEBUG > 1
+	Debug( LDAP_DEBUG_ANY, "delete: %04lx at %d\n", (long) id, x );
+	idl_dump( ids );
+#elif IDL_DEBUG > 0
+	wt_idl_check( ids );
+#endif
+
+	if (WT_IDL_IS_RANGE( ids )) {
+		/* If deleting a range boundary, adjust */
+		if ( ids[1] == id )
+			ids[1]++;
+		else if ( ids[2] == id )
+			ids[2]--;
+		/* deleting from inside a range is a no-op */
+
+		/* If the range has collapsed, re-adjust */
+		if ( ids[1] > ids[2] )
+			ids[0] = 0;
+		else if ( ids[1] == ids[2] )
+			ids[1] = 1;
+		return 0;
+	}
+
+	x = wt_idl_search( ids, id );
+	assert( x > 0 );
+
+	if( x <= 0 ) {
+		/* internal error */
+		return -2;
+	}
+
+	if( x > ids[0] || ids[x] != id ) {
+		/* not found */
+		return -1;
+
+	} else if ( --ids[0] == 0 ) {
+		if( x != 1 ) {
+			return -3;
+		}
+
+	} else {
+		AC_MEMCPY( &ids[x], &ids[x+1], (1+ids[0]-x) * sizeof(ID) );
+	}
+
+#if IDL_DEBUG > 1
+	wt_idl_dump( ids );
+#elif IDL_DEBUG > 0
+	wt_idl_check( ids );
+#endif
+
+	return 0;
+}
+
+static char *
+wt_show_key(
+	char		*buf,
+	void		*val,
+	size_t		len )
+{
+	if ( len == 4 /* LUTIL_HASH_BYTES */ ) {
+		unsigned char *c = val;
+		sprintf( buf, "[%02x%02x%02x%02x]", c[0], c[1], c[2], c[3] );
+		return buf;
+	} else {
+		return val;
+	}
+}
+
+/*
+ * idl_intersection - return a = a intersection b
+ */
+int
+wt_idl_intersection(
+	ID *a,
+	ID *b )
+{
+	ID ida, idb;
+	ID idmax, idmin;
+	ID cursora = 0, cursorb = 0, cursorc;
+	int swap = 0;
+
+	if ( WT_IDL_IS_ZERO( a ) || WT_IDL_IS_ZERO( b ) ) {
+		a[0] = 0;
+		return 0;
+	}
+
+	idmin = IDL_MAX( WT_IDL_FIRST(a), WT_IDL_FIRST(b) );
+	idmax = IDL_MIN( WT_IDL_LAST(a), WT_IDL_LAST(b) );
+	if ( idmin > idmax ) {
+		a[0] = 0;
+		return 0;
+	} else if ( idmin == idmax ) {
+		a[0] = 1;
+		a[1] = idmin;
+		return 0;
+	}
+
+	if ( WT_IDL_IS_RANGE( a ) ) {
+		if ( WT_IDL_IS_RANGE(b) ) {
+		/* If both are ranges, just shrink the boundaries */
+			a[1] = idmin;
+			a[2] = idmax;
+			return 0;
+		} else {
+		/* Else swap so that b is the range, a is a list */
+			ID *tmp = a;
+			a = b;
+			b = tmp;
+			swap = 1;
+		}
+	}
+
+	/* If a range completely covers the list, the result is
+	 * just the list. If idmin to idmax is contiguous, just
+	 * turn it into a range.
+	 */
+	if ( WT_IDL_IS_RANGE( b )
+		&& WT_IDL_RANGE_FIRST( b ) <= WT_IDL_FIRST( a )
+		&& WT_IDL_RANGE_LAST( b ) >= WT_IDL_LLAST( a ) ) {
+		if (idmax - idmin + 1 == a[0])
+		{
+			a[0] = NOID;
+			a[1] = idmin;
+			a[2] = idmax;
+		}
+		goto done;
+	}
+
+	/* Fine, do the intersection one element at a time.
+	 * First advance to idmin in both IDLs.
+	 */
+	cursora = cursorb = idmin;
+	ida = wt_idl_first( a, &cursora );
+	idb = wt_idl_first( b, &cursorb );
+	cursorc = 0;
+
+	while( ida <= idmax || idb <= idmax ) {
+		if( ida == idb ) {
+			a[++cursorc] = ida;
+			ida = wt_idl_next( a, &cursora );
+			idb = wt_idl_next( b, &cursorb );
+		} else if ( ida < idb ) {
+			ida = wt_idl_next( a, &cursora );
+		} else {
+			idb = wt_idl_next( b, &cursorb );
+		}
+	}
+	a[0] = cursorc;
+done:
+	if (swap)
+		WT_IDL_CPY( b, a );
+
+	return 0;
+}
+
+
+/*
+ * idl_union - return a = a union b
+ */
+int
+wt_idl_union(
+	ID	*a,
+	ID	*b )
+{
+	ID ida, idb;
+	ID cursora = 0, cursorb = 0, cursorc;
+
+	if ( WT_IDL_IS_ZERO( b ) ) {
+		return 0;
+	}
+
+	if ( WT_IDL_IS_ZERO( a ) ) {
+		WT_IDL_CPY( a, b );
+		return 0;
+	}
+
+	if ( WT_IDL_IS_RANGE( a ) || WT_IDL_IS_RANGE(b) ) {
+over:		ida = IDL_MIN( WT_IDL_FIRST(a), WT_IDL_FIRST(b) );
+		idb = IDL_MAX( WT_IDL_LAST(a), WT_IDL_LAST(b) );
+		a[0] = NOID;
+		a[1] = ida;
+		a[2] = idb;
+		return 0;
+	}
+
+	ida = wt_idl_first( a, &cursora );
+	idb = wt_idl_first( b, &cursorb );
+
+	cursorc = b[0];
+
+	/* The distinct elements of a are cat'd to b */
+	while( ida != NOID || idb != NOID ) {
+		if ( ida < idb ) {
+			if( ++cursorc > WT_IDL_UM_MAX ) {
+				goto over;
+			}
+			b[cursorc] = ida;
+			ida = wt_idl_next( a, &cursora );
+
+		} else {
+			if ( ida == idb )
+				ida = wt_idl_next( a, &cursora );
+			idb = wt_idl_next( b, &cursorb );
+		}
+	}
+
+	/* b is copied back to a in sorted order */
+	a[0] = cursorc;
+	cursora = 1;
+	cursorb = 1;
+	cursorc = b[0]+1;
+	while (cursorb <= b[0] || cursorc <= a[0]) {
+		if (cursorc > a[0])
+			idb = NOID;
+		else
+			idb = b[cursorc];
+		if (cursorb <= b[0] && b[cursorb] < idb)
+			a[cursora++] = b[cursorb++];
+		else {
+			a[cursora++] = idb;
+			cursorc++;
+		}
+	}
+
+	return 0;
+}
+
+
+#if 0
+/*
+ * wt_idl_notin - return a intersection ~b (or a minus b)
+ */
+int
+wt_idl_notin(
+	ID	*a,
+	ID	*b,
+	ID *ids )
+{
+	ID ida, idb;
+	ID cursora = 0, cursorb = 0;
+
+	if( WT_IDL_IS_ZERO( a ) ||
+		WT_IDL_IS_ZERO( b ) ||
+		WT_IDL_IS_RANGE( b ) )
+	{
+		WT_IDL_CPY( ids, a );
+		return 0;
+	}
+
+	if( WT_IDL_IS_RANGE( a ) ) {
+		WT_IDL_CPY( ids, a );
+		return 0;
+	}
+
+	ida = wt_idl_first( a, &cursora ),
+	idb = wt_idl_first( b, &cursorb );
+
+	ids[0] = 0;
+
+	while( ida != NOID ) {
+		if ( idb == NOID ) {
+			/* we could shortcut this */
+			ids[++ids[0]] = ida;
+			ida = wt_idl_next( a, &cursora );
+
+		} else if ( ida < idb ) {
+			ids[++ids[0]] = ida;
+			ida = wt_idl_next( a, &cursora );
+
+		} else if ( ida > idb ) {
+			idb = wt_idl_next( b, &cursorb );
+
+		} else {
+			ida = wt_idl_next( a, &cursora );
+			idb = wt_idl_next( b, &cursorb );
+		}
+	}
+
+	return 0;
+}
+#endif
+
+ID wt_idl_first( ID *ids, ID *cursor )
+{
+	ID pos;
+
+	if ( ids[0] == 0 ) {
+		*cursor = NOID;
+		return NOID;
+	}
+
+	if ( WT_IDL_IS_RANGE( ids ) ) {
+		if( *cursor < ids[1] ) {
+			*cursor = ids[1];
+		}
+		return *cursor;
+	}
+
+	if ( *cursor == 0 )
+		pos = 1;
+	else
+		pos = wt_idl_search( ids, *cursor );
+
+	if( pos > ids[0] ) {
+		return NOID;
+	}
+
+	*cursor = pos;
+	return ids[pos];
+}
+
+ID wt_idl_next( ID *ids, ID *cursor )
+{
+	if ( WT_IDL_IS_RANGE( ids ) ) {
+		if( ids[2] < ++(*cursor) ) {
+			return NOID;
+		}
+		return *cursor;
+	}
+
+	if ( ++(*cursor) <= ids[0] ) {
+		return ids[*cursor];
+	}
+
+	return NOID;
+}
+
+/* Add one ID to an unsorted list. We ensure that the first element is the
+ * minimum and the last element is the maximum, for fast range compaction.
+ *   this means IDLs up to length 3 are always sorted...
+ */
+int wt_idl_append_one( ID *ids, ID id )
+{
+	if (WT_IDL_IS_RANGE( ids )) {
+		/* if already in range, treat as a dup */
+		if (id >= WT_IDL_RANGE_FIRST(ids) && id <= WT_IDL_RANGE_LAST(ids))
+			return -1;
+		if (id < WT_IDL_RANGE_FIRST(ids))
+			ids[1] = id;
+		else if (id > WT_IDL_RANGE_LAST(ids))
+			ids[2] = id;
+		return 0;
+	}
+	if ( ids[0] ) {
+		ID tmp;
+
+		if (id < ids[1]) {
+			tmp = ids[1];
+			ids[1] = id;
+			id = tmp;
+		}
+		if ( ids[0] > 1 && id < ids[ids[0]] ) {
+			tmp = ids[ids[0]];
+			ids[ids[0]] = id;
+			id = tmp;
+		}
+	}
+	ids[0]++;
+	if ( ids[0] >= WT_IDL_UM_MAX ) {
+		ids[0] = NOID;
+		ids[2] = id;
+	} else {
+		ids[ids[0]] = id;
+	}
+	return 0;
+}
+
+/* Append sorted list b to sorted list a. The result is unsorted but
+ * a[1] is the min of the result and a[a[0]] is the max.
+ */
+int wt_idl_append( ID *a, ID *b )
+{
+	ID ida, idb, tmp, swap = 0;
+
+	if ( WT_IDL_IS_ZERO( b ) ) {
+		return 0;
+	}
+
+	if ( WT_IDL_IS_ZERO( a ) ) {
+		WT_IDL_CPY( a, b );
+		return 0;
+	}
+
+	ida = WT_IDL_LAST( a );
+	idb = WT_IDL_LAST( b );
+	if ( WT_IDL_IS_RANGE( a ) || WT_IDL_IS_RANGE(b) ||
+		a[0] + b[0] >= WT_IDL_UM_MAX ) {
+		a[2] = IDL_MAX( ida, idb );
+		a[1] = IDL_MIN( a[1], b[1] );
+		a[0] = NOID;
+		return 0;
+	}
+
+	if ( b[0] > 1 && ida > idb ) {
+		swap = idb;
+		a[a[0]] = idb;
+		b[b[0]] = ida;
+	}
+
+	if ( b[1] < a[1] ) {
+		tmp = a[1];
+		a[1] = b[1];
+	} else {
+		tmp = b[1];
+	}
+	a[0]++;
+	a[a[0]] = tmp;
+
+	if ( b[0] > 1 ) {
+		int i = b[0] - 1;
+		AC_MEMCPY(a+a[0]+1, b+2, i * sizeof(ID));
+		a[0] += i;
+	}
+	if ( swap ) {
+		b[b[0]] = swap;
+	}
+	return 0;
+}
+
+#if 1
+
+/* Quicksort + Insertion sort for small arrays */
+
+#define SMALL	8
+#define	SWAP(a,b)	itmp=(a);(a)=(b);(b)=itmp
+
+void
+wt_idl_sort( ID *ids, ID *tmp )
+{
+	int *istack = (int *)tmp; /* Private stack, not used by caller */
+	int i,j,k,l,ir,jstack;
+	ID a, itmp;
+
+	if ( WT_IDL_IS_RANGE( ids ))
+		return;
+
+	ir = ids[0];
+	l = 1;
+	jstack = 0;
+	for(;;) {
+		if (ir - l < SMALL) {	/* Insertion sort */
+			for (j=l+1;j<=ir;j++) {
+				a = ids[j];
+				for (i=j-1;i>=1;i--) {
+					if (ids[i] <= a) break;
+					ids[i+1] = ids[i];
+				}
+				ids[i+1] = a;
+			}
+			if (jstack == 0) break;
+			ir = istack[jstack--];
+			l = istack[jstack--];
+		} else {
+			k = (l + ir) >> 1;	/* Choose median of left, center, right */
+			SWAP(ids[k], ids[l+1]);
+			if (ids[l] > ids[ir]) {
+				SWAP(ids[l], ids[ir]);
+			}
+			if (ids[l+1] > ids[ir]) {
+				SWAP(ids[l+1], ids[ir]);
+			}
+			if (ids[l] > ids[l+1]) {
+				SWAP(ids[l], ids[l+1]);
+			}
+			i = l+1;
+			j = ir;
+			a = ids[l+1];
+			for(;;) {
+				do i++; while(ids[i] < a);
+				do j--; while(ids[j] > a);
+				if (j < i) break;
+				SWAP(ids[i],ids[j]);
+			}
+			ids[l+1] = ids[j];
+			ids[j] = a;
+			jstack += 2;
+			if (ir-i+1 >= j-l) {
+				istack[jstack] = ir;
+				istack[jstack-1] = i;
+				ir = j-1;
+			} else {
+				istack[jstack] = j-1;
+				istack[jstack-1] = l;
+				l = i;
+			}
+		}
+	}
+}
+
+#else
+
+/* 8 bit Radix sort + insertion sort
+ *
+ * based on code from http://www.cubic.org/docs/radix.htm
+ * with improvements by ebackes@symas.com and hyc@symas.com
+ *
+ * This code is O(n) but has a relatively high constant factor. For lists
+ * up to ~50 Quicksort is slightly faster; up to ~100 they are even.
+ * Much faster than quicksort for lists longer than ~100. Insertion
+ * sort is actually superior for lists <50.
+ */
+
+#define BUCKETS	(1<<8)
+#define SMALL	50
+
+void
+wt_idl_sort( ID *ids, ID *tmp )
+{
+	int count, soft_limit, phase = 0, size = ids[0];
+	ID *idls[2];
+	unsigned char *maxv = (unsigned char *)&ids[size];
+
+	if ( WT_IDL_IS_RANGE( ids ))
+		return;
+
+	/* Use insertion sort for small lists */
+	if ( size <= SMALL ) {
+		int i,j;
+		ID a;
+
+		for (j=1;j<=size;j++) {
+			a = ids[j];
+			for (i=j-1;i>=1;i--) {
+				if (ids[i] <= a) break;
+				ids[i+1] = ids[i];
+			}
+			ids[i+1] = a;
+		}
+		return;
+	}
+
+	tmp[0] = size;
+	idls[0] = ids;
+	idls[1] = tmp;
+
+#if BYTE_ORDER == BIG_ENDIAN
+    for (soft_limit = 0; !maxv[soft_limit]; soft_limit++);
+#else
+    for (soft_limit = sizeof(ID)-1; !maxv[soft_limit]; soft_limit--);
+#endif
+
+	for (
+#if BYTE_ORDER == BIG_ENDIAN
+	count = sizeof(ID)-1; count >= soft_limit; --count
+#else
+	count = 0; count <= soft_limit; ++count
+#endif
+	) {
+		unsigned int num[BUCKETS], * np, n, sum;
+		int i;
+        ID *sp, *source, *dest;
+        unsigned char *bp, *source_start;
+
+		source = idls[phase]+1;
+		dest = idls[phase^1]+1;
+		source_start =  ((unsigned char *) source) + count;
+
+        np = num;
+        for ( i = BUCKETS; i > 0; --i ) *np++ = 0;
+
+		/* count occurrences of every byte value */
+		bp = source_start;
+        for ( i = size; i > 0; --i, bp += sizeof(ID) )
+				num[*bp]++;
+
+		/* transform count into index by summing elements and storing
+		 * into same array
+		 */
+        sum = 0;
+        np = num;
+        for ( i = BUCKETS; i > 0; --i ) {
+                n = *np;
+                *np++ = sum;
+                sum += n;
+        }
+
+		/* fill dest with the right values in the right place */
+		bp = source_start;
+        sp = source;
+        for ( i = size; i > 0; --i, bp += sizeof(ID) ) {
+                np = num + *bp;
+                dest[*np] = *sp++;
+                ++(*np);
+        }
+		phase ^= 1;
+	}
+
+	/* copy back from temp if needed */
+	if ( phase ) {
+		ids++; tmp++;
+		for ( count = 0; count < size; ++count )
+			*ids++ = *tmp++;
+	}
+}
+#endif	/* Quick vs Radix */
+
diff --git a/servers/slapd/back-wt/idl.h b/servers/slapd/back-wt/idl.h
new file mode 100644
index 0000000..d323e54
--- /dev/null
+++ b/servers/slapd/back-wt/idl.h
@@ -0,0 +1,80 @@
+/* OpenLDAP WiredTiger backend */
+/* $OpenLDAP$ */
+/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
+ *
+ * Copyright 2002-2022 The OpenLDAP Foundation.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted only as authorized by the OpenLDAP
+ * Public License.
+ *
+ * A copy of this license is available in the file LICENSE in the
+ * top-level directory of the distribution or, alternatively, at
+ * <http://www.OpenLDAP.org/license.html>.
+ */
+/* ACKNOWLEDGEMENTS:
+ * This work was developed by HAMANO Tsukasa <hamano@osstech.co.jp>
+ * based on back-bdb for inclusion in OpenLDAP Software.
+ * WiredTiger is a product of MongoDB Inc.
+ */
+
+#ifndef _WT_IDL_H_
+#define _WT_IDL_H_
+
+/* IDL sizes - likely should be even bigger
+ *   limiting factors: sizeof(ID), thread stack size
+ */
+#define	WT_IDL_LOGN	16	/* DB_SIZE is 2^16, UM_SIZE is 2^17 */
+#define WT_IDL_DB_SIZE		(1<<WT_IDL_LOGN)
+#define WT_IDL_UM_SIZE		(1<<(WT_IDL_LOGN+1))
+#define WT_IDL_UM_SIZEOF	(WT_IDL_UM_SIZE * sizeof(ID))
+
+#define WT_IDL_DB_MAX		(WT_IDL_DB_SIZE-1)
+
+#define WT_IDL_UM_MAX		(WT_IDL_UM_SIZE-1)
+
+#define WT_IDL_IS_RANGE(ids)	((ids)[0] == NOID)
+#define WT_IDL_RANGE_SIZE		(3)
+#define WT_IDL_RANGE_SIZEOF	(WT_IDL_RANGE_SIZE * sizeof(ID))
+#define WT_IDL_SIZEOF(ids)		((WT_IDL_IS_RANGE(ids) \
+	? WT_IDL_RANGE_SIZE : ((ids)[0]+1)) * sizeof(ID))
+
+#define WT_IDL_RANGE_FIRST(ids)	((ids)[1])
+#define WT_IDL_RANGE_LAST(ids)		((ids)[2])
+
+#define WT_IDL_RANGE( ids, f, l ) \
+	do { \
+		(ids)[0] = NOID; \
+		(ids)[1] = (f);  \
+		(ids)[2] = (l);  \
+	} while(0)
+
+#define WT_IDL_ZERO(ids) \
+	do { \
+		(ids)[0] = 0; \
+		(ids)[1] = 0; \
+		(ids)[2] = 0; \
+	} while(0)
+
+#define WT_IDL_IS_ZERO(ids) ( (ids)[0] == 0 )
+#define WT_IDL_IS_ALL( range, ids ) ( (ids)[0] == NOID \
+	&& (ids)[1] <= (range)[1] && (range)[2] <= (ids)[2] )
+
+#define WT_IDL_CPY( dst, src ) (AC_MEMCPY( dst, src, WT_IDL_SIZEOF( src ) ))
+
+#define WT_IDL_ID( wi, ids, id ) WT_IDL_RANGE( ids, id, ((wi)->wi_lastid) )
+#define WT_IDL_ALL( wi, ids ) WT_IDL_RANGE( ids, 1, ((wi)->wi_lastid) )
+
+#define WT_IDL_FIRST( ids )	( (ids)[1] )
+#define WT_IDL_LLAST( ids )	( (ids)[(ids)[0]] )
+#define WT_IDL_LAST( ids )		( WT_IDL_IS_RANGE(ids) \
+	? (ids)[2] : (ids)[(ids)[0]] )
+
+#define WT_IDL_N( ids )		( WT_IDL_IS_RANGE(ids) \
+	? ((ids)[2]-(ids)[1])+1 : (ids)[0] )
+
+LDAP_BEGIN_DECL
+LDAP_END_DECL
+
+#endif
diff --git a/servers/slapd/back-wt/index.c b/servers/slapd/back-wt/index.c
new file mode 100644
index 0000000..3301977
--- /dev/null
+++ b/servers/slapd/back-wt/index.c
@@ -0,0 +1,423 @@
+/* OpenLDAP WiredTiger backend */
+/* $OpenLDAP$ */
+/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
+ *
+ * Copyright 2002-2022 The OpenLDAP Foundation.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted only as authorized by the OpenLDAP
+ * Public License.
+ *
+ * A copy of this license is available in the file LICENSE in the
+ * top-level directory of the distribution or, alternatively, at
+ * <http://www.OpenLDAP.org/license.html>.
+ */
+/* ACKNOWLEDGEMENTS:
+ * This work was developed by HAMANO Tsukasa <hamano@osstech.co.jp>
+ * based on back-bdb for inclusion in OpenLDAP Software.
+ * WiredTiger is a product of MongoDB Inc.
+ */
+
+#include "portable.h"
+
+#include <stdio.h>
+#include <ac/string.h>
+#include "back-wt.h"
+#include "slap-config.h"
+
+static char presence_keyval[] = {0,0};
+static struct berval presence_key = BER_BVC(presence_keyval);
+
+AttrInfo *wt_index_mask(
+	Backend *be,
+	AttributeDescription *desc,
+	struct berval *atname )
+{
+	AttributeType *at;
+	AttrInfo *ai = wt_attr_mask( be->be_private, desc );
+
+	if( ai ) {
+		*atname = desc->ad_cname;
+		return ai;
+	}
+
+	/* If there is a tagging option, did we ever index the base
+	 * type? If so, check for mask, otherwise it's not there.
+	 */
+	if( slap_ad_is_tagged( desc ) && desc != desc->ad_type->sat_ad ) {
+		/* has tagging option */
+		ai = wt_attr_mask( be->be_private, desc->ad_type->sat_ad );
+
+		if ( ai && !( ai->ai_indexmask & SLAP_INDEX_NOTAGS ) ) {
+			*atname = desc->ad_type->sat_cname;
+			return ai;
+		}
+	}
+
+	/* see if supertype defined mask for its subtypes */
+	for( at = desc->ad_type; at != NULL ; at = at->sat_sup ) {
+		/* If no AD, we've never indexed this type */
+		if ( !at->sat_ad ) continue;
+
+		ai = wt_attr_mask( be->be_private, at->sat_ad );
+
+		if ( ai && !( ai->ai_indexmask & SLAP_INDEX_NOSUBTYPES ) ) {
+			*atname = at->sat_cname;
+			return ai;
+		}
+	}
+
+	return 0;
+}
+
+/* This function is only called when evaluating search filters.
+ */
+int wt_index_param(
+	Backend *be,
+	AttributeDescription *desc,
+	int ftype,
+	slap_mask_t *maskp,
+	struct berval *prefixp )
+{
+	AttrInfo *ai;
+	slap_mask_t mask, type = 0;
+
+	ai = wt_index_mask( be, desc, prefixp );
+
+	if ( !ai ) {
+		/* TODO: add monitor */
+		return LDAP_INAPPROPRIATE_MATCHING;
+	}
+	mask = ai->ai_indexmask;
+
+	switch( ftype ) {
+	case LDAP_FILTER_PRESENT:
+		type = SLAP_INDEX_PRESENT;
+		if( IS_SLAP_INDEX( mask, SLAP_INDEX_PRESENT ) ) {
+			*prefixp = presence_key;
+			*maskp = mask;
+			return LDAP_SUCCESS;
+		}
+		break;
+
+	case LDAP_FILTER_APPROX:
+		type = SLAP_INDEX_APPROX;
+		if ( desc->ad_type->sat_approx ) {
+			if( IS_SLAP_INDEX( mask, SLAP_INDEX_APPROX ) ) {
+				*maskp = mask;
+				return LDAP_SUCCESS;
+			}
+			break;
+		}
+
+		/* Use EQUALITY rule and index for approximate match */
+		/* fall thru */
+
+	case LDAP_FILTER_EQUALITY:
+		type = SLAP_INDEX_EQUALITY;
+		if( IS_SLAP_INDEX( mask, SLAP_INDEX_EQUALITY ) ) {
+			*maskp = mask;
+			return LDAP_SUCCESS;
+		}
+		break;
+
+	case LDAP_FILTER_SUBSTRINGS:
+		type = SLAP_INDEX_SUBSTR;
+		if( IS_SLAP_INDEX( mask, SLAP_INDEX_SUBSTR ) ) {
+			*maskp = mask;
+			return LDAP_SUCCESS;
+		}
+		break;
+
+	default:
+		return LDAP_OTHER;
+	}
+
+	/* TODO: add monitor index */
+	return LDAP_INAPPROPRIATE_MATCHING;
+}
+
+static int indexer(
+	Operation *op,
+	wt_ctx *wc,
+	AttributeDescription *ad,
+	struct berval *atname,
+	BerVarray vals,
+	ID id,
+	int opid,
+	slap_mask_t mask )
+{
+	int rc = LDAP_SUCCESS, i;
+	struct berval *keys;
+	WT_CURSOR *cursor = NULL;
+	assert( mask != 0 );
+
+	cursor = wt_index_open(wc, atname, 1);
+	if( !cursor ) {
+		Debug( LDAP_DEBUG_ANY,
+			   "indexer: open index cursor failed: %s\n",
+			   atname->bv_val );
+		goto done;
+	}
+
+	if( IS_SLAP_INDEX( mask, SLAP_INDEX_PRESENT ) ) {
+		rc = wt_key_change( op->o_bd, cursor, &presence_key, id, opid );
+		if( rc ) {
+			goto done;
+		}
+	}
+
+	if( IS_SLAP_INDEX( mask, SLAP_INDEX_EQUALITY ) ) {
+		rc = ad->ad_type->sat_equality->smr_indexer(
+			LDAP_FILTER_EQUALITY,
+			mask,
+			ad->ad_type->sat_syntax,
+			ad->ad_type->sat_equality,
+			atname, vals, &keys, op->o_tmpmemctx );
+
+		if( rc == LDAP_SUCCESS && keys != NULL ) {
+			for( i=0; keys[i].bv_val != NULL; i++ ) {
+				rc = wt_key_change( op->o_bd, cursor, &keys[i], id, opid );
+				if( rc ) {
+					ber_bvarray_free_x( keys, op->o_tmpmemctx );
+					goto done;
+				}
+			}
+			ber_bvarray_free_x( keys, op->o_tmpmemctx );
+		}
+		rc = LDAP_SUCCESS;
+	}
+
+	if( IS_SLAP_INDEX( mask, SLAP_INDEX_APPROX ) ) {
+		rc = ad->ad_type->sat_approx->smr_indexer(
+			LDAP_FILTER_APPROX,
+			mask,
+			ad->ad_type->sat_syntax,
+			ad->ad_type->sat_approx,
+			atname, vals, &keys, op->o_tmpmemctx );
+
+		if( rc == LDAP_SUCCESS && keys != NULL ) {
+			for( i=0; keys[i].bv_val != NULL; i++ ) {
+				rc = wt_key_change( op->o_bd, cursor, &keys[i], id, opid );
+				if( rc ) {
+					ber_bvarray_free_x( keys, op->o_tmpmemctx );
+					goto done;
+				}
+			}
+			ber_bvarray_free_x( keys, op->o_tmpmemctx );
+		}
+
+		rc = LDAP_SUCCESS;
+	}
+
+	if( IS_SLAP_INDEX( mask, SLAP_INDEX_SUBSTR ) ) {
+		rc = ad->ad_type->sat_substr->smr_indexer(
+			LDAP_FILTER_SUBSTRINGS,
+			mask,
+			ad->ad_type->sat_syntax,
+			ad->ad_type->sat_substr,
+			atname, vals, &keys, op->o_tmpmemctx );
+
+		if( rc == LDAP_SUCCESS && keys != NULL ) {
+			for( i=0; keys[i].bv_val != NULL; i++ ) {
+				rc = wt_key_change( op->o_bd, cursor, &keys[i], id, opid );
+				if( rc ) {
+					ber_bvarray_free_x( keys, op->o_tmpmemctx );
+					goto done;
+				}
+			}
+			ber_bvarray_free_x( keys, op->o_tmpmemctx );
+		}
+
+		rc = LDAP_SUCCESS;
+	}
+
+done:
+	cursor->close(cursor);
+	return rc;
+}
+
+static int index_at_values(
+	Operation *op,
+	wt_ctx *wc,
+	AttributeDescription *ad,
+	AttributeType *type,
+	struct berval *tags,
+	BerVarray vals,
+	ID id,
+	int opid )
+{
+	int rc = LDAP_SUCCESS;
+	slap_mask_t mask = 0;
+	int ixop = opid;
+	AttrInfo *ai = NULL;
+
+	if ( opid == WT_INDEX_UPDATE_OP )
+		ixop = SLAP_INDEX_ADD_OP;
+
+	if( type->sat_sup ) {
+		/* recurse */
+		rc = index_at_values( op, wc, NULL,
+							  type->sat_sup, tags,
+							  vals, id, opid );
+
+		if( rc ) return rc;
+	}
+
+	/* If this type has no AD, we've never used it before */
+	if( type->sat_ad ) {
+		ai = wt_attr_mask( op->o_bd->be_private, type->sat_ad );
+		if ( ai ) {
+			#ifdef LDAP_COMP_MATCH
+			/* component indexing */
+			if ( ai->ai_cr ) {
+				ComponentReference *cr;
+				for( cr = ai->ai_cr ; cr ; cr = cr->cr_next ) {
+					rc = indexer( op, wc, cr->cr_ad, &type->sat_cname,
+								  cr->cr_nvals, id, ixop,
+								  cr->cr_indexmask );
+				}
+			}
+			#endif
+			ad = type->sat_ad;
+			/* If we're updating the index, just set the new bits that aren't
+             * already in the old mask.
+             */
+			if ( opid == WT_INDEX_UPDATE_OP )
+				mask = ai->ai_newmask & ~ai->ai_indexmask;
+			else
+				/* For regular updates, if there is a newmask use it. Otherwise
+				 * just use the old mask.
+				 */
+				mask = ai->ai_newmask ? ai->ai_newmask : ai->ai_indexmask;
+			if( mask ) {
+				rc = indexer( op, wc, ad, &type->sat_cname,
+							  vals, id, ixop, mask );
+				if( rc ) return rc;
+			}
+		}
+	}
+
+	if( tags->bv_len ) {
+		AttributeDescription *desc;
+
+		desc = ad_find_tags( type, tags );
+		if( desc ) {
+			ai = wt_attr_mask( op->o_bd->be_private, desc );
+
+			if( ai ) {
+				if ( opid == WT_INDEX_UPDATE_OP )
+					mask = ai->ai_newmask & ~ai->ai_indexmask;
+				else
+					mask = ai->ai_newmask ? ai->ai_newmask : ai->ai_indexmask;
+				if ( mask ) {
+					rc = indexer( op, wc, desc, &desc->ad_cname,
+								  vals, id, ixop, mask );
+
+					if( rc ) {
+						return rc;
+					}
+				}
+			}
+		}
+	}
+
+	return LDAP_SUCCESS;
+}
+
+int wt_index_values(
+	Operation *op,
+	wt_ctx *wc,
+	AttributeDescription *desc,
+	BerVarray vals,
+	ID id,
+	int opid )
+{
+	int rc;
+
+	/* Never index ID 0 */
+	if ( id == 0 )
+		return 0;
+
+	rc = index_at_values( op, wc, desc,
+						  desc->ad_type, &desc->ad_tags,
+						  vals, id, opid );
+
+	return rc;
+}
+
+int
+wt_index_entry( Operation *op, wt_ctx *wc, int opid, Entry *e )
+{
+	int rc;
+	Attribute *ap = e->e_attrs;
+
+	if ( e->e_id == 0 )
+		return 0;
+
+	Debug( LDAP_DEBUG_TRACE, "=> index_entry_%s( %ld, \"%s\" )\n",
+		   opid == SLAP_INDEX_DELETE_OP ? "del" : "add",
+		   (long) e->e_id, e->e_dn ? e->e_dn : "" );
+
+	for ( ; ap != NULL; ap = ap->a_next ) {
+		rc = wt_index_values( op, wc, ap->a_desc,
+							  ap->a_nvals, e->e_id, opid );
+		if( rc != LDAP_SUCCESS ) {
+			Debug( LDAP_DEBUG_TRACE,
+				   "<= index_entry_%s( %ld, \"%s\" ) failure\n",
+				   opid == SLAP_INDEX_ADD_OP ? "add" : "del",
+				   (long) e->e_id, e->e_dn );
+			return rc;
+		}
+	}
+
+	Debug( LDAP_DEBUG_TRACE, "<= index_entry_%s( %ld, \"%s\" ) success\n",
+		   opid == SLAP_INDEX_DELETE_OP ? "del" : "add",
+		   (long) e->e_id, e->e_dn ? e->e_dn : "" );
+	return 0;
+}
+
+WT_CURSOR *
+wt_index_open(wt_ctx *wc, struct berval *name, int create)
+{
+	WT_CURSOR *cursor = NULL;
+	WT_SESSION *session = wc->session;
+	char uri[1024];
+	int rc;
+
+	snprintf(uri, sizeof(uri), "table:%s", name->bv_val);
+
+	rc = session->open_cursor(session, uri, NULL, "overwrite=false", &cursor);
+	if (rc == ENOENT && create) {
+		rc = session->create(session, uri,
+							 "key_format=uQ,"
+							 "value_format=x,"
+							 "columns=(key, id, none)");
+		if( rc ) {
+			Debug( LDAP_DEBUG_ANY,
+				   "wt_index_open: table \"%s\": "
+				   "cannot create index table: %s (%d)\n",
+				   uri, wiredtiger_strerror(rc), rc);
+			return NULL;
+		}
+		rc = session->open_cursor(session, uri, NULL,
+								  "overwrite=false", &cursor);
+	}
+	if ( rc ) {
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_index_open: table \"%s\": "
+			   ": open cursor failed: %s (%d)\n",
+			   uri, wiredtiger_strerror(rc), rc);
+		return NULL;
+	}
+	return cursor;
+}
+
+/*
+ * Local variables:
+ * indent-tabs-mode: t
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */
diff --git a/servers/slapd/back-wt/init.c b/servers/slapd/back-wt/init.c
new file mode 100644
index 0000000..cc0c53a
--- /dev/null
+++ b/servers/slapd/back-wt/init.c
@@ -0,0 +1,385 @@
+/* OpenLDAP WiredTiger backend */
+/* $OpenLDAP$ */
+/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
+ *
+ * Copyright 2002-2022 The OpenLDAP Foundation.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted only as authorized by the OpenLDAP
+ * Public License.
+ *
+ * A copy of this license is available in the file LICENSE in the
+ * top-level directory of the distribution or, alternatively, at
+ * <http://www.OpenLDAP.org/license.html>.
+ */
+/* ACKNOWLEDGEMENTS:
+ * This work was developed by HAMANO Tsukasa <hamano@osstech.co.jp>
+ * based on back-bdb for inclusion in OpenLDAP Software.
+ * WiredTiger is a product of MongoDB Inc.
+ */
+
+#include "portable.h"
+
+#include <stdio.h>
+#include <ac/string.h>
+#include "back-wt.h"
+#include "slap-config.h"
+
+static int
+wt_db_init( BackendDB *be, ConfigReply *cr )
+{
+	struct wt_info *wi;
+
+	Debug( LDAP_DEBUG_TRACE, "wt_db_init: Initializing wt backend\n" );
+
+	/* allocate backend-database-specific stuff */
+	wi = ch_calloc( 1, sizeof(struct wt_info) );
+	wi->wi_home = ch_strdup( SLAPD_DEFAULT_DB_DIR );
+	wi->wi_config = ch_calloc( 1, WT_CONFIG_MAX + 1);
+	if ( slapMode & SLAP_TOOL_READONLY ) {
+		strcpy(wi->wi_config, "readonly");
+	} else {
+		strcpy(wi->wi_config, "create");
+	}
+	wi->wi_lastid = 0;
+	wi->wi_search_stack_depth = DEFAULT_SEARCH_STACK_DEPTH;
+	wi->wi_search_stack = NULL;
+	wi->wi_flags = WT_USE_IDLCACHE;
+
+	be->be_private = wi;
+	be->be_cf_ocs = be->bd_info->bi_cf_ocs;
+
+	return LDAP_SUCCESS;
+}
+
+static int
+wt_db_open( BackendDB *be, ConfigReply *cr )
+{
+	struct wt_info *wi = (struct wt_info *) be->be_private;
+	int rc;
+	struct stat st;
+	WT_SESSION *session = NULL;
+	WT_SESSION *cache_session = NULL;
+
+	if ( be->be_suffix == NULL ) {
+		Debug( LDAP_DEBUG_ANY, "wt_db_open: need suffix.\n" );
+		return -1;
+	}
+
+	Debug( LDAP_DEBUG_ARGS,
+		   "wt_db_open: \"%s\", home=%s, config=%s\n",
+		   be->be_suffix[0].bv_val, wi->wi_home, wi->wi_config );
+
+	/* Check existence of home. Any error means trouble */
+	rc = stat( wi->wi_home, &st );
+	if( rc ) {
+		int saved_errno = errno;
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_db_open: database \"%s\": "
+			   "cannot access database directory \"%s\" (%d).\n",
+			   be->be_suffix[0].bv_val, wi->wi_home, saved_errno );
+		return -1;
+	}
+
+	/* back-wt is always clean */
+	be->be_flags |= SLAP_DBFLAG_CLEAN;
+	
+	/* Open and create database */
+	rc = wiredtiger_open(wi->wi_home, NULL,
+						 wi->wi_config, &wi->wi_conn);
+	if( rc ) {
+		int saved_errno = errno;
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_db_open: database \"%s\": "
+			   "cannot open database \"%s\" (%d).\n",
+			   be->be_suffix[0].bv_val, wi->wi_home, saved_errno );
+		return -1;
+	}
+
+	rc = wi->wi_conn->open_session(wi->wi_conn, NULL, NULL, &session);
+	if( rc ) {
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_db_open: database \"%s\": "
+			   "cannot open session: \"%s\"\n",
+			   be->be_suffix[0].bv_val, wiredtiger_strerror(rc) );
+		return -1;
+	}
+
+	if ( slapMode & SLAP_TOOL_READONLY ) {
+		goto readonly;
+	}
+
+	/* checking for obsolete table */
+	rc = session->verify(session, WT_INDEX_REVDN, NULL);
+	if ( !rc ) {
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_db_open: database \"%s\": "
+			   "incompatible wiredtiger table, please restore from LDIF.\n",
+			   be->be_suffix[0].bv_val );
+		return -1;
+	}
+
+	/* create tables and indexes */
+	rc = session->create(session,
+						 WT_TABLE_ID2ENTRY,
+						 "key_format=Q,"
+						 "value_format=Su,"
+						 "columns=(id,dn,entry)");
+	if( rc ) {
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_db_open: database \"%s\": "
+			   "cannot create entry table: \"%s\"\n",
+			   be->be_suffix[0].bv_val, wiredtiger_strerror(rc) );
+		return -1;
+	}
+
+	rc = session->create(session,
+						 WT_TABLE_DN2ID,
+						 "key_format=S,"
+						 "value_format=SQQ,"
+						 "columns=(revdn,ndn,id,pid)");
+	if( rc ) {
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_db_open: database \"%s\": "
+			   "cannot create entry table: \"%s\"\n",
+			   be->be_suffix[0].bv_val, wiredtiger_strerror(rc) );
+		return -1;
+	}
+
+	/* not using dn2id index for id2entry table */
+	rc = session->create(session, WT_INDEX_DN, "columns=(dn)");
+	if( rc ) {
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_db_open: database \"%s\": "
+			   "cannot create dn index: \"%s\"\n",
+			   be->be_suffix[0].bv_val, wiredtiger_strerror(rc) );
+		return -1;
+	}
+
+	rc = session->create(session, WT_INDEX_PID, "columns=(pid)");
+	if( rc ) {
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_db_open: database \"%s\": "
+			   "cannot create pid index: \"%s\"\n",
+			   be->be_suffix[0].bv_val, wiredtiger_strerror(rc) );
+		return -1;
+	}
+
+	rc = session->create(session, WT_INDEX_NDN, "columns=(ndn)");
+	if( rc ) {
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_db_open: database \"%s\": "
+			   "cannot create ndn index: \"%s\"\n",
+			   be->be_suffix[0].bv_val, wiredtiger_strerror(rc) );
+		return -1;
+	}
+
+	/* open in-memory database for idlcache */
+	rc = wiredtiger_open(be->be_suffix[0].bv_val, NULL,
+						 "in_memory=true", &wi->wi_cache);
+	if( rc ) {
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_db_open: database \"%s\": "
+			   "cannot open database for cache (%s).\n",
+			   be->be_suffix[0].bv_val, wiredtiger_strerror(rc) );
+		return -1;
+	}
+
+	rc = wi->wi_cache->open_session(wi->wi_cache, NULL, NULL, &cache_session);
+	if( rc ) {
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_db_open: database \"%s\": "
+			   "cannot open session for cache: \"%s\"\n",
+			   be->be_suffix[0].bv_val, wiredtiger_strerror(rc) );
+		return -1;
+	}
+
+	rc = cache_session->create(cache_session,
+							   WT_TABLE_IDLCACHE,
+							   "key_format=Sb,"
+							   "value_format=u,"
+							   "columns=(ndn,scope,idl)");
+	if( rc ) {
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_db_open: database \"%s\": "
+			   "cannot create idlcache table: \"%s\"\n",
+			   be->be_suffix[0].bv_val, wiredtiger_strerror(rc) );
+		return -1;
+	}
+
+readonly:
+	rc = wt_last_id( be, session, &wi->wi_lastid);
+	if (rc) {
+		snprintf( cr->msg, sizeof(cr->msg), "database \"%s\": "
+				  "last_id() failed: %s(%d).",
+				  be->be_suffix[0].bv_val, wiredtiger_strerror(rc), rc );
+        Debug( LDAP_DEBUG_ANY, "wt_db_open: %s\n", cr->msg );
+		return rc;
+	}
+
+	if (session) {
+		session->close(session, NULL);
+	}
+	if (cache_session) {
+		cache_session->close(cache_session, NULL);
+	}
+
+	wi->wi_flags |= WT_IS_OPEN;
+    return LDAP_SUCCESS;
+}
+
+static int
+wt_db_close( BackendDB *be, ConfigReply *cr )
+{
+	struct wt_info *wi = (struct wt_info *) be->be_private;
+	int rc;
+
+	if ( wi->wi_cache ) {
+		rc = wi->wi_cache->close(wi->wi_cache, NULL);
+		if( rc ) {
+			Debug( LDAP_DEBUG_ANY,
+				   "wt_db_close: cannot close cache database (%d).\n", rc );
+			return -1;
+		}
+	}
+
+	if ( wi->wi_conn ) {
+		rc = wi->wi_conn->close(wi->wi_conn, NULL);
+		if( rc ) {
+			Debug( LDAP_DEBUG_ANY,
+				   "wt_db_close: cannot close database (%d).\n", rc );
+			return -1;
+		}
+		wi->wi_flags &= ~WT_IS_OPEN;
+	}
+
+    return LDAP_SUCCESS;
+}
+
+static int
+wt_db_destroy( Backend *be, ConfigReply *cr )
+{
+	struct wt_info *wi = (struct wt_info *) be->be_private;
+
+	if( wi->wi_home ) {
+		ch_free( wi->wi_home );
+		wi->wi_home = NULL;
+	}
+
+	if( wi->wi_config ) {
+		ch_free( wi->wi_config );
+		wi->wi_config = NULL;
+	}
+
+	wt_attr_index_destroy( wi );
+	ch_free( wi );
+	be->be_private = NULL;
+
+	return LDAP_SUCCESS;
+}
+
+int
+wt_back_initialize( BackendInfo *bi )
+{
+	static const char *controls[] = {
+		LDAP_CONTROL_ASSERT,
+		LDAP_CONTROL_MANAGEDSAIT,
+		LDAP_CONTROL_NOOP,
+		LDAP_CONTROL_PAGEDRESULTS,
+		LDAP_CONTROL_PRE_READ,
+		LDAP_CONTROL_POST_READ,
+		LDAP_CONTROL_SUBENTRIES,
+		LDAP_CONTROL_X_PERMISSIVE_MODIFY,
+#ifdef LDAP_X_TXN
+		LDAP_CONTROL_X_TXN_SPEC,
+#endif
+		NULL
+	};
+
+	/* initialize the database system */
+	Debug( LDAP_DEBUG_TRACE,
+		   "wt_back_initialize: initialize WiredTiger backend\n" );
+
+	bi->bi_flags |=
+		SLAP_BFLAG_INCREMENT |
+		SLAP_BFLAG_SUBENTRIES |
+		SLAP_BFLAG_ALIASES |
+		SLAP_BFLAG_REFERRALS;
+
+	bi->bi_controls = (char **)controls;
+
+	/* version check */
+	Debug( LDAP_DEBUG_TRACE,
+		   "wt_back_initialize: %s\n",
+		   wiredtiger_version(NULL, NULL, NULL) );
+
+	bi->bi_open = 0;
+	bi->bi_close = 0;
+	bi->bi_config = 0;
+	bi->bi_destroy = 0;
+
+	bi->bi_db_init = wt_db_init;
+	bi->bi_db_config = config_generic_wrapper;
+	bi->bi_db_open = wt_db_open;
+	bi->bi_db_close = wt_db_close;
+	bi->bi_db_destroy = wt_db_destroy;
+
+	bi->bi_op_add = wt_add;
+	bi->bi_op_bind = wt_bind;
+	bi->bi_op_unbind = 0;
+	bi->bi_op_search = wt_search;
+	bi->bi_op_compare = wt_compare;
+	bi->bi_op_modify = wt_modify;
+	bi->bi_op_modrdn = wt_modrdn;
+	bi->bi_op_delete = wt_delete;
+	bi->bi_op_abandon = 0;
+
+	bi->bi_extended = wt_extended;
+#ifdef LDAP_X_TXN
+	bi->bi_op_txn = 0;
+#endif
+
+	bi->bi_chk_referrals = 0;
+	bi->bi_operational = wt_operational;
+
+	bi->bi_has_subordinates = wt_hasSubordinates;
+	bi->bi_entry_release_rw = wt_entry_release;
+	bi->bi_entry_get_rw = wt_entry_get;
+
+	bi->bi_tool_entry_open = wt_tool_entry_open;
+	bi->bi_tool_entry_close = wt_tool_entry_close;
+	bi->bi_tool_entry_first = backend_tool_entry_first;
+	bi->bi_tool_entry_first_x = wt_tool_entry_first_x;
+	bi->bi_tool_entry_next = wt_tool_entry_next;
+	bi->bi_tool_entry_get = wt_tool_entry_get;
+	bi->bi_tool_entry_put = wt_tool_entry_put;
+	bi->bi_tool_entry_reindex = wt_tool_entry_reindex;
+	bi->bi_tool_sync = 0;
+	bi->bi_tool_dn2id_get = wt_tool_dn2id_get;
+	bi->bi_tool_entry_modify = wt_tool_entry_modify;
+
+#if LDAP_VENDOR_VERSION_MINOR == X || LDAP_VENDOR_VERSION_MINOR >= 5
+	bi->bi_tool_entry_delete = wt_tool_entry_delete;
+#endif
+
+	bi->bi_connection_init = 0;
+	bi->bi_connection_destroy = 0;
+
+	return wt_back_init_cf( bi );
+}
+
+#if SLAPD_WT == SLAPD_MOD_DYNAMIC
+
+/* conditionally define the init_module() function */
+SLAP_BACKEND_INIT_MODULE( wt )
+
+#endif /* SLAPD_WT == SLAPD_MOD_DYNAMIC */
+
+/*
+ * Local variables:
+ * indent-tabs-mode: t
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */
diff --git a/servers/slapd/back-wt/key.c b/servers/slapd/back-wt/key.c
new file mode 100644
index 0000000..ea86829
--- /dev/null
+++ b/servers/slapd/back-wt/key.c
@@ -0,0 +1,162 @@
+/* OpenLDAP WiredTiger backend */
+/* $OpenLDAP$ */
+/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
+ *
+ * Copyright 2002-2022 The OpenLDAP Foundation.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted only as authorized by the OpenLDAP
+ * Public License.
+ *
+ * A copy of this license is available in the file LICENSE in the
+ * top-level directory of the distribution or, alternatively, at
+ * <http://www.OpenLDAP.org/license.html>.
+ */
+/* ACKNOWLEDGEMENTS:
+ * This work was developed by HAMANO Tsukasa <hamano@osstech.co.jp>
+ * based on back-bdb for inclusion in OpenLDAP Software.
+ * WiredTiger is a product of MongoDB Inc.
+ */
+
+#include "portable.h"
+
+#include <stdio.h>
+#include <ac/string.h>
+#include "back-wt.h"
+#include "slap-config.h"
+#include "idl.h"
+
+/* read a key */
+int
+wt_key_read(
+	Backend *be,
+	WT_CURSOR *cursor,
+	struct berval *bkey,
+	ID *ids,
+	WT_CURSOR **saved_cursor,
+	int get_flag
+	)
+{
+	int rc;
+	WT_ITEM key;
+	int exact;
+	WT_ITEM key2;
+	ID id;
+	int comp;
+	long scanned = 0;
+
+	Debug( LDAP_DEBUG_TRACE, "=> key_read\n" );
+
+	WT_IDL_ZERO(ids);
+	bv2ITEM(bkey, &key);
+	cursor->set_key(cursor, &key, 0);
+	rc = cursor->search_near(cursor, &exact);
+	switch( rc ){
+	case 0:
+		break;
+	case WT_NOTFOUND:
+		rc = LDAP_SUCCESS;
+		goto done;
+	default:
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_key_read: search_near failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc);
+		goto done;
+	}
+	do {
+		scanned++;
+		rc = cursor->get_key(cursor, &key2, &id);
+		if( rc ){
+			Debug( LDAP_DEBUG_ANY,
+				   "wt_key_read: get_key failed: %s (%d)\n",
+				   wiredtiger_strerror(rc), rc );
+			break;
+		}
+		comp = 0;
+		if (key.size != key2.size ||
+			(comp = memcmp(key2.data, key.data, key.size))) {
+			if(comp > 0){
+				break;
+			}
+			if(exact < 0){
+				rc = cursor->next(cursor);
+				if (rc) {
+					break;
+				}else{
+					continue;
+				}
+			}
+			break;
+		}
+		exact = 0;
+		wt_idl_append_one(ids, id);
+		rc = cursor->next(cursor);
+	} while(rc == 0);
+
+	if ( rc == WT_NOTFOUND && exact == 0 ) {
+		rc = LDAP_SUCCESS;
+	}
+
+done:
+	if( rc != LDAP_SUCCESS ) {
+		Debug( LDAP_DEBUG_TRACE, "<= wt_key_read: failed (%d) %ld scanned\n",
+			   rc, scanned );
+	} else {
+		Debug( LDAP_DEBUG_TRACE, "<= wt_key_read %ld candidates %ld scanned\n",
+			   (long) WT_IDL_N(ids), scanned );
+	}
+
+	return rc;
+}
+
+/* Add or remove stuff from index files */
+int
+wt_key_change(
+	Backend *be,
+	WT_CURSOR *cursor,
+	struct berval *k,
+	ID id,
+	int op
+)
+{
+	int	rc;
+	WT_ITEM item;
+
+	Debug( LDAP_DEBUG_TRACE, "=> key_change(%s,%lx)\n",
+		   op == SLAP_INDEX_ADD_OP ? "ADD":"DELETE", (long) id );
+
+	bv2ITEM(k, &item);
+	cursor->set_key(cursor, &item, id);
+	cursor->set_value(cursor, NULL);
+
+	if (op == SLAP_INDEX_ADD_OP) {
+		/* Add values */
+		rc = cursor->insert(cursor);
+		if ( rc == WT_DUPLICATE_KEY ) rc = 0;
+	} else {
+		/* Delete values */
+		rc = cursor->remove(cursor);
+		if ( rc == WT_NOTFOUND ) rc = 0;
+	}
+	if( rc ) {
+		if ( rc != WT_ROLLBACK ) {
+			Debug( LDAP_DEBUG_ANY,
+				   "wt_key_change: error: %s (%d)\n",
+				   wiredtiger_strerror(rc), rc);
+		}
+		return rc;
+	}
+
+	Debug( LDAP_DEBUG_TRACE, "<= key_change %d\n", rc );
+
+	return rc;
+}
+
+/*
+ * Local variables:
+ * indent-tabs-mode: t
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */
diff --git a/servers/slapd/back-wt/modify.c b/servers/slapd/back-wt/modify.c
new file mode 100644
index 0000000..d78c438
--- /dev/null
+++ b/servers/slapd/back-wt/modify.c
@@ -0,0 +1,714 @@
+/* OpenLDAP WiredTiger backend */
+/* $OpenLDAP$ */
+/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
+ *
+ * Copyright 2002-2022 The OpenLDAP Foundation.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted only as authorized by the OpenLDAP
+ * Public License.
+ *
+ * A copy of this license is available in the file LICENSE in the
+B * top-level directory of the distribution or, alternatively, at
+ * <http://www.OpenLDAP.org/license.html>.
+ */
+/* ACKNOWLEDGEMENTS:
+ * This work was developed by HAMANO Tsukasa <hamano@osstech.co.jp>
+ * based on back-bdb for inclusion in OpenLDAP Software.
+ * WiredTiger is a product of MongoDB Inc.
+ */
+#include "portable.h"
+
+#include <stdio.h>
+#include <ac/string.h>
+#include "back-wt.h"
+#include "slap-config.h"
+
+static struct berval scbva[] = {
+	BER_BVC("glue"),
+	BER_BVNULL
+};
+
+static void
+wt_modify_idxflags(
+	Operation *op,
+	AttributeDescription *desc,
+	int got_delete,
+	Attribute *newattrs,
+	Attribute *oldattrs )
+{
+	struct berval	ix_at;
+	AttrInfo	*ai;
+
+	/* check if modified attribute was indexed
+	 * but not in case of NOOP... */
+	ai = wt_index_mask( op->o_bd, desc, &ix_at );
+	if ( ai ) {
+		if ( got_delete ) {
+			Attribute	*ap;
+			struct berval	ix2;
+
+			ap = attr_find( oldattrs, desc );
+			if ( ap ) ap->a_flags |= SLAP_ATTR_IXDEL;
+
+			/* Find all other attrs that index to same slot */
+			for ( ap = newattrs; ap; ap = ap->a_next ) {
+				ai = wt_index_mask( op->o_bd, ap->a_desc, &ix2 );
+				if ( ai && ix2.bv_val == ix_at.bv_val )
+					ap->a_flags |= SLAP_ATTR_IXADD;
+			}
+
+		} else {
+			Attribute	*ap;
+
+			ap = attr_find( newattrs, desc );
+			if ( ap ) ap->a_flags |= SLAP_ATTR_IXADD;
+		}
+	}
+}
+
+int wt_modify_internal(
+	Operation *op,
+	wt_ctx *wc,
+	Modifications *modlist,
+	Entry *e,
+	const char **text,
+	char *textbuf,
+	size_t textlen )
+{
+	int rc, err;
+	Modification	*mod;
+	Modifications	*ml;
+	Attribute	*save_attrs;
+	Attribute	*ap;
+	int			glue_attr_delete = 0;
+	int			got_delete;
+
+	Debug( LDAP_DEBUG_TRACE, "wt_modify_internal: 0x%08lx: %s\n",
+		   e->e_id, e->e_dn );
+
+	if ( !acl_check_modlist( op, e, modlist )) {
+		return LDAP_INSUFFICIENT_ACCESS;
+	}
+
+	/* save_attrs will be disposed of by caller */
+	save_attrs = e->e_attrs;
+	e->e_attrs = attrs_dup( e->e_attrs );
+
+	for ( ml = modlist; ml != NULL; ml = ml->sml_next ) {
+		int match;
+		mod = &ml->sml_mod;
+		switch( mod->sm_op ) {
+		case LDAP_MOD_ADD:
+		case LDAP_MOD_REPLACE:
+			if ( mod->sm_desc == slap_schema.si_ad_structuralObjectClass ) {
+				value_match( &match, slap_schema.si_ad_structuralObjectClass,
+					slap_schema.si_ad_structuralObjectClass->
+						ad_type->sat_equality,
+					SLAP_MR_VALUE_OF_ATTRIBUTE_SYNTAX,
+					&mod->sm_values[0], &scbva[0], text );
+				if ( !match ) glue_attr_delete = 1;
+			}
+		}
+		if ( glue_attr_delete )
+			break;
+	}
+
+	if ( glue_attr_delete ) {
+		Attribute	**app = &e->e_attrs;
+		while ( *app != NULL ) {
+			if ( !is_at_operational( (*app)->a_desc->ad_type )) {
+				Attribute *save = *app;
+				*app = (*app)->a_next;
+				attr_free( save );
+				continue;
+			}
+			app = &(*app)->a_next;
+		}
+	}
+
+	for ( ml = modlist; ml != NULL; ml = ml->sml_next ) {
+		mod = &ml->sml_mod;
+		got_delete = 0;
+
+		switch ( mod->sm_op ) {
+		case LDAP_MOD_ADD:
+			Debug(LDAP_DEBUG_ARGS,
+				  "wt_modify_internal: add %s\n",
+				  mod->sm_desc->ad_cname.bv_val );
+			err = modify_add_values( e, mod, get_permissiveModify(op),
+									 text, textbuf, textlen );
+			if( err != LDAP_SUCCESS ) {
+				Debug(LDAP_DEBUG_ARGS, "wt_modify_internal: %d %s\n",
+					  err, *text );
+			}
+			break;
+
+		case LDAP_MOD_DELETE:
+			if ( glue_attr_delete ) {
+				err = LDAP_SUCCESS;
+				break;
+			}
+
+			Debug( LDAP_DEBUG_ARGS,
+				  "wt_modify_internal: delete %s\n",
+				  mod->sm_desc->ad_cname.bv_val );
+			err = modify_delete_values( e, mod, get_permissiveModify(op),
+										text, textbuf, textlen );
+			if( err != LDAP_SUCCESS ) {
+				Debug(LDAP_DEBUG_ARGS,
+					  "wt_modify_internal: %d %s\n", err, *text );
+			} else {
+				got_delete = 1;
+			}
+			break;
+
+		case LDAP_MOD_REPLACE:
+			Debug( LDAP_DEBUG_ARGS,
+				  "wt_modify_internal: replace %s\n",
+				  mod->sm_desc->ad_cname.bv_val );
+			err = modify_replace_values( e, mod, get_permissiveModify(op),
+										 text, textbuf, textlen );
+			if( err != LDAP_SUCCESS ) {
+				Debug(LDAP_DEBUG_ARGS,
+					  "wt_modify_internal: %d %s\n", err, *text );
+			} else {
+				got_delete = 1;
+			}
+			break;
+
+		case LDAP_MOD_INCREMENT:
+			Debug( LDAP_DEBUG_ARGS,
+				  "wt_modify_internal: increment %s\n",
+				  mod->sm_desc->ad_cname.bv_val );
+			err = modify_increment_values( e, mod, get_permissiveModify(op),
+										   text, textbuf, textlen );
+			if( err != LDAP_SUCCESS ) {
+				Debug( LDAP_DEBUG_ARGS,
+					  "wt_modify_internal: %d %s\n", err, *text );
+			} else {
+				got_delete = 1;
+			}
+			break;
+
+		case SLAP_MOD_SOFTADD:
+			Debug( LDAP_DEBUG_ARGS,
+				  "wt_modify_internal: softadd %s\n",
+				  mod->sm_desc->ad_cname.bv_val );
+			/* Avoid problems in index_add_mods()
+			 * We need to add index if necessary.
+			 */
+			mod->sm_op = LDAP_MOD_ADD;
+
+			err = modify_add_values( e, mod, get_permissiveModify(op),
+				text, textbuf, textlen );
+
+			mod->sm_op = SLAP_MOD_SOFTADD;
+
+			if ( err == LDAP_TYPE_OR_VALUE_EXISTS ) {
+				err = LDAP_SUCCESS;
+			}
+
+			if( err != LDAP_SUCCESS ) {
+				Debug(LDAP_DEBUG_ARGS, "wt_modify_internal: %d %s\n",
+					err, *text );
+			}
+			break;
+
+		case SLAP_MOD_SOFTDEL:
+			Debug( LDAP_DEBUG_ARGS,
+				  "wt_modify_internal: softdel %s\n",
+				  mod->sm_desc->ad_cname.bv_val );
+			/* Avoid problems in index_delete_mods()
+			 * We need to add index if necessary.
+			 */
+			mod->sm_op = LDAP_MOD_DELETE;
+
+			err = modify_delete_values( e, mod, get_permissiveModify(op),
+										text, textbuf, textlen );
+
+			mod->sm_op = SLAP_MOD_SOFTDEL;
+
+			if ( err == LDAP_SUCCESS ) {
+				got_delete = 1;
+			} else if ( err == LDAP_NO_SUCH_ATTRIBUTE ) {
+				err = LDAP_SUCCESS;
+			}
+
+			if( err != LDAP_SUCCESS ) {
+				Debug(LDAP_DEBUG_ARGS, "wt_modify_internal: %d %s\n",
+					  err, *text );
+			}
+			break;
+
+		case SLAP_MOD_ADD_IF_NOT_PRESENT:
+			if ( attr_find( e->e_attrs, mod->sm_desc ) != NULL ) {
+				/* skip */
+				err = LDAP_SUCCESS;
+				break;
+			}
+
+			Debug(LDAP_DEBUG_ARGS,
+				  "wt_modify_internal: add_if_not_present %s\n",
+				  mod->sm_desc->ad_cname.bv_val );
+			/* Avoid problems in index_add_mods()
+			 * We need to add index if necessary.
+			 */
+			mod->sm_op = LDAP_MOD_ADD;
+
+			err = modify_add_values( e, mod, get_permissiveModify(op),
+									 text, textbuf, textlen );
+
+			mod->sm_op = SLAP_MOD_ADD_IF_NOT_PRESENT;
+
+			if( err != LDAP_SUCCESS ) {
+				Debug(LDAP_DEBUG_ARGS, "wt_modify_internal: %d %s\n",
+					  err, *text );
+			}
+			break;
+
+		default:
+			Debug(LDAP_DEBUG_ANY, "wt_modify_internal: invalid op %d\n",
+				  mod->sm_op );
+			*text = "Invalid modify operation";
+			err = LDAP_OTHER;
+			Debug(LDAP_DEBUG_ARGS, "wt_modify_internal: %d %s\n",
+				  err, *text );
+		}
+
+		if ( err != LDAP_SUCCESS ) {
+			attrs_free( e->e_attrs );
+			e->e_attrs = save_attrs;
+			/* unlock entry, delete from cache */
+			return err;
+		}
+
+		/* If objectClass was modified, reset the flags */
+		if ( mod->sm_desc == slap_schema.si_ad_objectClass ) {
+			e->e_ocflags = 0;
+		}
+
+		if ( glue_attr_delete ) e->e_ocflags = 0;
+
+
+		/* check if modified attribute was indexed
+		 * but not in case of NOOP... */
+		if ( !op->o_noop ) {
+			wt_modify_idxflags( op, mod->sm_desc, got_delete, e->e_attrs, save_attrs );
+		}
+
+	}
+
+	/* check that the entry still obeys the schema */
+	ap = NULL;
+	rc = entry_schema_check( op, e, save_attrs, get_relax(op), 0, &ap,
+		text, textbuf, textlen );
+	if ( rc != LDAP_SUCCESS || op->o_noop ) {
+		attrs_free( e->e_attrs );
+		/* clear the indexing flags */
+		for ( ap = save_attrs; ap != NULL; ap = ap->a_next ) {
+			ap->a_flags &= ~(SLAP_ATTR_IXADD|SLAP_ATTR_IXDEL);
+		}
+		e->e_attrs = save_attrs;
+
+		if ( rc != LDAP_SUCCESS ) {
+			Debug( LDAP_DEBUG_ANY,
+				"entry failed schema check: %s\n", *text );
+		}
+
+		/* if NOOP then silently revert to saved attrs */
+		return rc;
+	}
+
+	/* structuralObjectClass modified! */
+	if ( ap ) {
+		assert( ap->a_desc == slap_schema.si_ad_structuralObjectClass );
+		if ( !op->o_noop ) {
+			wt_modify_idxflags( op, slap_schema.si_ad_structuralObjectClass,
+								1, e->e_attrs, save_attrs );
+		}
+	}
+
+	/* update the indices of the modified attributes */
+
+	/* start with deleting the old index entries */
+	for ( ap = save_attrs; ap != NULL; ap = ap->a_next ) {
+		if ( ap->a_flags & SLAP_ATTR_IXDEL ) {
+			struct berval *vals;
+			Attribute *a2;
+			ap->a_flags &= ~SLAP_ATTR_IXDEL;
+			a2 = attr_find( e->e_attrs, ap->a_desc );
+			if ( a2 ) {
+				/* need to detect which values were deleted */
+				int i, j;
+				/* let add know there were deletes */
+				if ( a2->a_flags & SLAP_ATTR_IXADD )
+					a2->a_flags |= SLAP_ATTR_IXDEL;
+				vals = op->o_tmpalloc( (ap->a_numvals + 1) *
+					sizeof(struct berval), op->o_tmpmemctx );
+				j = 0;
+				for ( i=0; i < ap->a_numvals; i++ ) {
+					rc = attr_valfind( a2, SLAP_MR_ASSERTED_VALUE_NORMALIZED_MATCH,
+						&ap->a_nvals[i], NULL, op->o_tmpmemctx );
+					/* Save deleted values */
+					if ( rc == LDAP_NO_SUCH_ATTRIBUTE )
+						vals[j++] = ap->a_nvals[i];
+				}
+				BER_BVZERO(vals+j);
+			} else {
+				/* attribute was completely deleted */
+				vals = ap->a_nvals;
+			}
+			rc = 0;
+			if ( !BER_BVISNULL( vals )) {
+				rc = wt_index_values( op, wc, ap->a_desc,
+									  vals, e->e_id, SLAP_INDEX_DELETE_OP );
+				if ( rc != LDAP_SUCCESS ) {
+					Debug( LDAP_DEBUG_ANY,
+						   "%s: attribute \"%s\" index delete failure\n",
+						   op->o_log_prefix, ap->a_desc->ad_cname.bv_val );
+					attrs_free( e->e_attrs );
+					e->e_attrs = save_attrs;
+				}
+			}
+			if ( vals != ap->a_nvals )
+				op->o_tmpfree( vals, op->o_tmpmemctx );
+			if ( rc ) return rc;
+		}
+	}
+
+	/* add the new index entries */
+	for ( ap = e->e_attrs; ap != NULL; ap = ap->a_next ) {
+		if (ap->a_flags & SLAP_ATTR_IXADD) {
+			ap->a_flags &= ~SLAP_ATTR_IXADD;
+			if ( ap->a_flags & SLAP_ATTR_IXDEL ) {
+				/* if any values were deleted, we must readd index
+				 * for all remaining values.
+				 */
+				ap->a_flags &= ~SLAP_ATTR_IXDEL;
+				rc = wt_index_values( op, wc, ap->a_desc, ap->a_nvals,
+									  e->e_id, SLAP_INDEX_ADD_OP );
+			} else {
+				int found = 0;
+				/* if this was only an add, we only need to index
+				 * the added values.
+				 */
+				for ( ml = modlist; ml != NULL; ml = ml->sml_next ) {
+					struct berval *vals;
+					if ( ml->sml_desc != ap->a_desc || !ml->sml_numvals )
+						continue;
+					found = 1;
+					switch( ml->sml_op ) {
+					case LDAP_MOD_ADD:
+					case LDAP_MOD_REPLACE:
+					case LDAP_MOD_INCREMENT:
+					case SLAP_MOD_SOFTADD:
+					case SLAP_MOD_ADD_IF_NOT_PRESENT:
+						if ( ml->sml_op == LDAP_MOD_INCREMENT )
+							vals = ap->a_nvals;
+						else if ( ml->sml_nvalues )
+							vals = ml->sml_nvalues;
+						else
+							vals = ml->sml_values;
+						rc = wt_index_values( op, wc, ap->a_desc,
+											  vals, e->e_id, SLAP_INDEX_ADD_OP );
+						break;
+					}
+					if ( rc )
+						break;
+				}
+				/* This attr was affected by a modify of a subtype, so
+				 * there was no direct match in the modlist. Just readd
+				 * all of its values.
+				 */
+				if ( !found ) {
+					rc = wt_index_values( op, wc, ap->a_desc, ap->a_nvals,
+										  e->e_id, SLAP_INDEX_ADD_OP );
+				}
+			}
+			if ( rc != LDAP_SUCCESS ) {
+				Debug( LDAP_DEBUG_ANY,
+				       "%s: attribute \"%s\" index add failure\n",
+					   op->o_log_prefix, ap->a_desc->ad_cname.bv_val );
+				attrs_free( e->e_attrs );
+				e->e_attrs = save_attrs;
+				return rc;
+			}
+		}
+	}
+
+	return rc;
+}
+
+int
+wt_modify( Operation *op, SlapReply *rs )
+{
+	struct wt_info *wi = (struct wt_info *) op->o_bd->be_private;
+	wt_ctx *wc = NULL;
+	Entry *e = NULL;
+	int		manageDSAit = get_manageDSAit( op );
+	char textbuf[SLAP_TEXT_BUFLEN];
+	size_t textlen = sizeof textbuf;
+	Entry		dummy = {0};
+
+	LDAPControl **preread_ctrl = NULL;
+	LDAPControl **postread_ctrl = NULL;
+	LDAPControl *ctrls[SLAP_MAX_RESPONSE_CONTROLS];
+	int num_ctrls = 0;
+
+	int rc;
+
+	Debug( LDAP_DEBUG_ARGS, "wt_modify: %s\n", op->o_req_dn.bv_val );
+
+#ifdef LDAP_X_TXN
+	if( op->o_txnSpec && txn_preop( op, rs ))
+		return rs->sr_err;
+#endif
+
+	ctrls[num_ctrls] = NULL;
+
+	wc = wt_ctx_get(op, wi);
+	if( !wc ){
+        Debug( LDAP_DEBUG_ANY, "wt_modify: wt_ctx_get failed\n" );
+		rs->sr_err = LDAP_OTHER;
+		rs->sr_text = "internal error";
+        send_ldap_result( op, rs );
+        return rs->sr_err;
+	}
+
+	/* Don't touch the opattrs, if this is a contextCSN update
+	 * initiated from updatedn */
+	if ( !be_isupdate(op) || !op->orm_modlist || op->orm_modlist->sml_next ||
+		 op->orm_modlist->sml_desc != slap_schema.si_ad_contextCSN ) {
+
+		slap_mods_opattrs( op, &op->orm_modlist, 1 );
+	}
+
+retry:
+	/* begin transaction */
+	wc->is_begin_transaction = 0;
+	rc = wc->session->begin_transaction(wc->session, "isolation=snapshot");
+	if( rc ) {
+		Debug( LDAP_DEBUG_TRACE,
+			   "wt_modify: begin_transaction failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		rs->sr_err = LDAP_OTHER;
+		rs->sr_text = "begin_transaction failed";
+		goto return_results;
+	}
+	wc->is_begin_transaction = 1;
+	Debug( LDAP_DEBUG_TRACE, "wt_modify: session id: %p\n", wc->session );
+
+	/* get entry */
+	rc = wt_dn2entry(op->o_bd, wc, &op->o_req_ndn, &e);
+	switch( rc ) {
+	case 0:
+		break;
+	case WT_NOTFOUND:
+		break;
+	default:
+		Debug( LDAP_DEBUG_ANY,
+			   "<== wt_modify: wt_dn2entry failed (%d)\n", rc );
+		rs->sr_err = LDAP_OTHER;
+		rs->sr_text = "internal error";
+		goto return_results;
+	}
+
+	if ( rc == WT_NOTFOUND ||
+		 ( !manageDSAit && e && is_entry_glue( e ))) {
+		if ( !e ) {
+			rc = wt_dn2aentry(op->o_bd, wc, &op->o_req_ndn, &e);
+			switch( rc ) {
+			case 0:
+				break;
+			case WT_NOTFOUND:
+				rs->sr_err = LDAP_NO_SUCH_OBJECT;
+				goto return_results;
+			default:
+				Debug( LDAP_DEBUG_ANY, "wt_modify: wt_dna2entry failed (%d)\n", rc );
+				rs->sr_err = LDAP_OTHER;
+				rs->sr_text = "internal error";
+				goto return_results;
+			}
+		}
+
+		rs->sr_matched = ch_strdup( e->e_dn );
+
+		if ( is_entry_referral( e ) ) {
+			BerVarray ref = get_entry_referrals( op, e );
+			rs->sr_ref = referral_rewrite( ref, &e->e_name,
+										   &op->o_req_dn, LDAP_SCOPE_DEFAULT );
+			ber_bvarray_free( ref );
+		} else {
+			rs->sr_ref = NULL;
+		}
+		rs->sr_flags = REP_MATCHED_MUSTBEFREED | REP_REF_MUSTBEFREED;
+		rs->sr_err = LDAP_REFERRAL;
+		send_ldap_result( op, rs );
+		goto done;
+	}
+
+	if ( !manageDSAit && is_entry_referral( e ) ) {
+		/* entry is a referral, don't allow modify */
+		rs->sr_ref = get_entry_referrals( op, e );
+
+		Debug( LDAP_DEBUG_TRACE, "wt_modify: entry is referral\n" );
+
+		rs->sr_err = LDAP_REFERRAL;
+		rs->sr_matched = e->e_name.bv_val;
+		rs->sr_flags = REP_REF_MUSTBEFREED;
+		send_ldap_result( op, rs );
+		rs->sr_matched = NULL;
+		goto done;
+	}
+
+	if ( get_assert( op ) &&
+		 ( test_filter( op, e, get_assertion( op )) != LDAP_COMPARE_TRUE ))
+	{
+		rs->sr_err = LDAP_ASSERTION_FAILED;
+		goto return_results;
+	}
+
+	if( op->o_preread ) {
+		if( preread_ctrl == NULL ) {
+			preread_ctrl = &ctrls[num_ctrls++];
+			ctrls[num_ctrls] = NULL;
+		}
+		if ( slap_read_controls( op, rs, e,
+			&slap_pre_read_bv, preread_ctrl ) )
+		{
+			Debug( LDAP_DEBUG_TRACE,
+				"<=- wt_modify: pre-read failed!\n" );
+			if ( op->o_preread & SLAP_CONTROL_CRITICAL ) {
+				/* FIXME: is it correct to abort
+				 * operation if control fails? */
+				goto return_results;
+			}
+		}
+	}
+
+	/* Modify the entry */
+	dummy = *e;
+	rs->sr_err = wt_modify_internal( op, wc, op->orm_modlist,
+									 &dummy, &rs->sr_text, textbuf, textlen );
+	switch ( rs->sr_err ) {
+	case LDAP_SUCCESS:
+		break;
+	case WT_ROLLBACK:
+		Debug (LDAP_DEBUG_TRACE, "wt_modify: rollback wt_modify_internal failed.\n" );
+		wc->session->rollback_transaction(wc->session, NULL);
+		goto retry;
+	default:
+		Debug( LDAP_DEBUG_ANY, "wt_modify: modify failed (%d)\n", rs->sr_err );
+		/* Only free attrs if they were dup'd.  */
+		if ( dummy.e_attrs == e->e_attrs ) dummy.e_attrs = NULL;
+		goto return_results;
+	}
+
+	/* change the entry itself */
+	rs->sr_err = wt_id2entry_update( op, wc, &dummy );
+	switch ( rs->sr_err ) {
+	case 0:
+		break;
+	case WT_ROLLBACK:
+		Debug (LDAP_DEBUG_TRACE, "wt_modify: rollback wt_id2entry_update failed.\n");
+		wc->session->rollback_transaction(wc->session, NULL);
+		goto retry;
+	case LDAP_ADMINLIMIT_EXCEEDED:
+		Debug( LDAP_DEBUG_ANY, "wt_modify: id2entry update failed (%d)\n",
+			   rs->sr_err);
+		rs->sr_text = "entry too big";
+		goto return_results;
+	default:
+		Debug( LDAP_DEBUG_ANY, "wt_modify: id2entry update failed (%d)\n",
+			   rs->sr_err);
+		rs->sr_err = LDAP_OTHER;
+		rs->sr_text = "entry update failed";
+		goto return_results;
+	}
+
+	if( op->o_postread ) {
+		if( postread_ctrl == NULL ) {
+			postread_ctrl = &ctrls[num_ctrls++];
+			ctrls[num_ctrls] = NULL;
+		}
+		if( slap_read_controls( op, rs, &dummy,
+								&slap_post_read_bv, postread_ctrl ) )
+		{
+			Debug( LDAP_DEBUG_TRACE,
+				   "<== wt_modify: post-read failed!\n");
+			if ( op->o_postread & SLAP_CONTROL_CRITICAL ) {
+				/* FIXME: is it correct to abort
+				 * operation if control fails? */
+				goto return_results;
+			}
+		}
+	}
+
+	if( op->o_noop ) {
+		rs->sr_err = LDAP_X_NO_OPERATION;
+		goto return_results;
+	}
+
+	/* Only free attrs if they were dup'd.  */
+	if ( dummy.e_attrs == e->e_attrs ) dummy.e_attrs = NULL;
+
+	rc = wc->session->commit_transaction(wc->session, NULL);
+	wc->is_begin_transaction = 0;
+	if( rc ) {
+		Debug( LDAP_DEBUG_TRACE,
+			   "<== wt_modify: commit failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		rs->sr_err = LDAP_OTHER;
+		rs->sr_text = "commit failed";
+		goto return_results;
+	}
+
+	Debug( LDAP_DEBUG_TRACE,
+		   "wt_modify: updated%s id=%08lx dn=\"%s\"\n",
+		   op->o_noop ? " (no-op)" : "",
+		   dummy.e_id, op->o_req_dn.bv_val );
+
+	rs->sr_err = LDAP_SUCCESS;
+	rs->sr_text = NULL;
+	if( num_ctrls ) rs->sr_ctrls = ctrls;
+
+return_results:
+	if( dummy.e_attrs ) {
+		attrs_free( dummy.e_attrs );
+	}
+	send_ldap_result( op, rs );
+
+done:
+	slap_graduate_commit_csn( op );
+
+	if( wc && wc->is_begin_transaction ){
+		Debug( LDAP_DEBUG_TRACE, "wt_modify: rollback transaction\n" );
+		wc->session->rollback_transaction(wc->session, NULL);
+		wc->is_begin_transaction = 0;
+	}
+
+	if( e != NULL ) {
+		wt_entry_return( e );
+	}
+
+	if( preread_ctrl != NULL && (*preread_ctrl) != NULL ) {
+		slap_sl_free( (*preread_ctrl)->ldctl_value.bv_val, op->o_tmpmemctx );
+		slap_sl_free( *preread_ctrl, op->o_tmpmemctx );
+	}
+	if( postread_ctrl != NULL && (*postread_ctrl) != NULL ) {
+		slap_sl_free( (*postread_ctrl)->ldctl_value.bv_val, op->o_tmpmemctx );
+		slap_sl_free( *postread_ctrl, op->o_tmpmemctx );
+	}
+
+	return rs->sr_err;
+}
+
+/*
+ * Local variables:
+ * indent-tabs-mode: t
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */
diff --git a/servers/slapd/back-wt/modrdn.c b/servers/slapd/back-wt/modrdn.c
new file mode 100644
index 0000000..faef948
--- /dev/null
+++ b/servers/slapd/back-wt/modrdn.c
@@ -0,0 +1,552 @@
+/* OpenLDAP WiredTiger backend */
+/* $OpenLDAP$ */
+/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
+ *
+ * Copyright 2002-2022 The OpenLDAP Foundation.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted only as authorized by the OpenLDAP
+ * Public License.
+ *
+ * A copy of this license is available in the file LICENSE in the
+ * top-level directory of the distribution or, alternatively, at
+ * <http://www.OpenLDAP.org/license.html>.
+ */
+/* ACKNOWLEDGEMENTS:
+ * This work was developed by HAMANO Tsukasa <hamano@osstech.co.jp>
+ * based on back-bdb for inclusion in OpenLDAP Software.
+ * WiredTiger is a product of MongoDB Inc.
+ */
+
+#include "portable.h"
+
+#include <stdio.h>
+#include "back-wt.h"
+#include "slap-config.h"
+
+int
+wt_modrdn( Operation *op, SlapReply *rs )
+{
+	struct wt_info *wi = (struct wt_info *) op->o_bd->be_private;
+	AttributeDescription *children = slap_schema.si_ad_children;
+	AttributeDescription *entry = slap_schema.si_ad_entry;
+	wt_ctx *wc = NULL;
+	Entry *e = NULL;
+	Entry *p = NULL;
+	Entry *ne = NULL;
+	Entry dummy = {0};
+
+	struct berval p_dn, p_ndn;
+	struct berval new_dn = {0, NULL}, new_ndn = {0, NULL};
+
+	Entry *np = NULL;             /* newSuperior Entry */
+	struct berval *np_dn = NULL;  /* newSuperior dn */
+	struct berval *np_ndn = NULL; /* newSuperior ndn */
+	struct berval *new_parent_dn = NULL; /* np_dn, p_dn, or NULL */
+
+	int manageDSAit = get_manageDSAit( op );
+	char textbuf[SLAP_TEXT_BUFLEN];
+	size_t textlen = sizeof textbuf;
+	LDAPControl **preread_ctrl = NULL;
+	LDAPControl **postread_ctrl = NULL;
+	LDAPControl *ctrls[SLAP_MAX_RESPONSE_CONTROLS];
+	int num_ctrls = 0;
+
+	int	rc;
+
+	int parent_is_glue = 0;
+	int parent_is_leaf = 0;
+
+	Debug( LDAP_DEBUG_TRACE, "==> wt_modrdn(%s -> newrdn=%s - newsup=%s)\n",
+		   op->o_req_dn.bv_val,
+		   op->oq_modrdn.rs_newrdn.bv_val,
+		   op->oq_modrdn.rs_newSup?op->oq_modrdn.rs_newSup->bv_val:"NULL" );
+
+	ctrls[num_ctrls] = NULL;
+
+	slap_mods_opattrs( op, &op->orr_modlist, 1 );
+
+	wc = wt_ctx_get(op, wi);
+	if( !wc ){
+		Debug( LDAP_DEBUG_ANY, "wt_modrdn: wt_ctx_get failed\n");
+		rs->sr_err = LDAP_OTHER;
+		rs->sr_text = "internal error";
+		send_ldap_result( op, rs );
+		return rs->sr_err;
+	}
+
+	/* get parent entry */
+	if ( be_issuffix( op->o_bd, &op->o_req_ndn ) ) {
+		rs->sr_err = LDAP_NAMING_VIOLATION;
+		rs->sr_text = "cannot rename suffix entry";
+		goto return_results;
+	} else {
+		dnParent( &op->o_req_ndn, &p_ndn );
+	}
+
+	rc = wt_dn2entry(op->o_bd, wc, &p_ndn, &p);
+	switch( rc ) {
+	case 0:
+		break;
+	case WT_NOTFOUND:
+		Debug( LDAP_DEBUG_ARGS,
+			   "<== wt_modrdn: parent does not exist %s\n", p_ndn.bv_val);
+		rs->sr_err = LDAP_NO_SUCH_OBJECT;
+		goto return_results;
+	default:
+		Debug( LDAP_DEBUG_ANY,
+			   "<== wt_modrdn: wt_dn2entry failed (%d)\n", rc );
+		rs->sr_err = LDAP_OTHER;
+		rs->sr_text = "internal error";
+		goto return_results;
+	}
+
+	/* check parent for "children" acl */
+	rc = access_allowed( op, p, children, NULL,
+						 op->oq_modrdn.rs_newSup == NULL ?
+						 ACL_WRITE : ACL_WDEL, NULL );
+
+	if ( !rc ) {
+		rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
+		Debug( LDAP_DEBUG_TRACE,
+			   "wt_modrdn: no access to parent\n");
+		rs->sr_text = "no write access to old parent's children";
+		goto return_results;
+	}
+
+	Debug( LDAP_DEBUG_TRACE,
+		   "wt_modrdn: wr to children of entry %s OK\n", p_ndn.bv_val );
+
+	if ( p_ndn.bv_val == slap_empty_bv.bv_val ) {
+		p_dn = slap_empty_bv;
+	} else {
+		dnParent( &op->o_req_dn, &p_dn );
+	}
+
+	Debug( LDAP_DEBUG_TRACE,
+		   "wt_modrdn: parent dn=%s\n", p_dn.bv_val );
+
+	/* get entry */
+	rc = wt_dn2entry(op->o_bd, wc, &op->o_req_ndn, &e);
+	switch( rc ) {
+	case 0:
+		break;
+	case WT_NOTFOUND:
+		break;
+	default:
+		Debug( LDAP_DEBUG_ANY,
+			   "<== wt_modrdn: wt_dn2entry failed (%d)\n", rc );
+		rs->sr_err = LDAP_OTHER;
+		rs->sr_text = "internal error";
+		goto return_results;
+	}
+
+	if ( rc == WT_NOTFOUND ||
+		 ( !manageDSAit && e && is_entry_glue( e ) )) {
+
+		if ( !e ) {
+			Debug( LDAP_DEBUG_ARGS,
+				   "<== wt_modrdn: no such object %s\n", op->o_req_dn.bv_val);
+			rc = wt_dn2aentry(op->o_bd, wc, &op->o_req_ndn, &e);
+			switch( rc ) {
+			case 0:
+				break;
+			case WT_NOTFOUND:
+				rs->sr_err = LDAP_NO_SUCH_OBJECT;
+				goto return_results;
+			default:
+				Debug( LDAP_DEBUG_ANY, "wt_modrdn: wt_dn2aentry failed (%d)\n", rc );
+				rs->sr_err = LDAP_OTHER;
+				rs->sr_text = "internal error";
+				goto return_results;
+			}
+		}
+
+		rs->sr_matched = ch_strdup( e->e_dn );
+
+		if ( is_entry_referral( e ) ) {
+			BerVarray ref = get_entry_referrals( op, e );
+			rs->sr_ref = referral_rewrite( ref, &e->e_name,
+										   &op->o_req_dn, LDAP_SCOPE_DEFAULT );
+			ber_bvarray_free( ref );
+		} else {
+			rs->sr_ref = NULL;
+		}
+		rs->sr_flags = REP_MATCHED_MUSTBEFREED | REP_REF_MUSTBEFREED;
+		rs->sr_err = LDAP_REFERRAL;
+		send_ldap_result( op, rs );
+		goto done;
+	}
+
+	if ( get_assert( op ) &&
+		 ( test_filter( op, e, get_assertion( op )) != LDAP_COMPARE_TRUE ))
+	{
+		rs->sr_err = LDAP_ASSERTION_FAILED;
+		goto return_results;
+	}
+
+	/* check write on old entry */
+	rc = access_allowed( op, e, entry, NULL, ACL_WRITE, NULL );
+	if ( !rc ) {
+		Debug( LDAP_DEBUG_TRACE, "wt_modrdn: no access to entry\n");
+		rs->sr_text = "no write access to old entry";
+		rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
+		goto return_results;
+	}
+
+	/* Can't do it if we have kids */
+	rc = wt_dn2id_has_children( op, wc, e->e_id );
+	if( rc != WT_NOTFOUND ) {
+		switch( rc ) {
+		case 0:
+			Debug(LDAP_DEBUG_ARGS, "<== wt_modrdn: non-leaf %s\n", op->o_req_dn.bv_val);
+			rs->sr_err = LDAP_NOT_ALLOWED_ON_NONLEAF;
+			rs->sr_text = "subtree rename not supported";
+			break;
+		default:
+			Debug(LDAP_DEBUG_ARGS,
+				  "<== wt_modrdn: has_children failed: %s (%d)\n",
+				  wiredtiger_strerror(rc), rc );
+			rs->sr_err = LDAP_OTHER;
+			rs->sr_text = "internal error";
+		}
+		goto return_results;
+	}
+
+	if (!manageDSAit && is_entry_referral( e ) ) {
+		/* parent is a referral, don't allow add */
+		rs->sr_ref = get_entry_referrals( op, e );
+
+		Debug( LDAP_DEBUG_TRACE,
+			   "wt_modrdn: entry %s is referral\n", e->e_dn );
+
+		rs->sr_err = LDAP_REFERRAL,
+		rs->sr_matched = e->e_name.bv_val;
+		send_ldap_result( op, rs );
+
+		ber_bvarray_free( rs->sr_ref );
+		rs->sr_ref = NULL;
+		rs->sr_matched = NULL;
+		goto done;
+	}
+	
+	new_parent_dn = &p_dn;	/* New Parent unless newSuperior given */
+	if ( op->oq_modrdn.rs_newSup != NULL ) {
+		Debug( LDAP_DEBUG_TRACE,
+			   "wt_modrdn: new parent \"%s\" requested...\n",
+			   op->oq_modrdn.rs_newSup->bv_val );
+
+		/* newSuperior == oldParent? */
+		if( dn_match( &p_ndn, op->oq_modrdn.rs_nnewSup ) ) {
+			Debug( LDAP_DEBUG_TRACE,
+				   "wt_modrdn: new parent \"%s\" same as the old parent \"%s\"\n",
+				   op->oq_modrdn.rs_newSup->bv_val, p_dn.bv_val );
+			op->oq_modrdn.rs_newSup = NULL; /* ignore newSuperior */
+		}
+	}
+
+	if ( op->oq_modrdn.rs_newSup != NULL ) {
+		if ( op->oq_modrdn.rs_newSup->bv_len ) {
+			np_dn = op->oq_modrdn.rs_newSup;
+			np_ndn = op->oq_modrdn.rs_nnewSup;
+
+			/* newSuperior == oldParent? - checked above */
+			/* newSuperior == entry being moved?, if so ==> ERROR */
+			if ( dnIsSuffix( np_ndn, &e->e_nname )) {
+				rs->sr_err = LDAP_NO_SUCH_OBJECT;
+				rs->sr_text = "new superior not found";
+				goto return_results;
+			}
+			/* Get Entry with dn=newSuperior. Does newSuperior exist? */
+			rc = wt_dn2entry(op->o_bd, wc, np_ndn, &np);
+			switch( rc ) {
+			case 0:
+				break;
+			case WT_NOTFOUND:
+				Debug( LDAP_DEBUG_ANY,
+					   "<== wt_modrdn: new superior not found: %s\n",
+					   np_ndn->bv_val );
+				rs->sr_err = LDAP_NO_SUCH_OBJECT;
+				rs->sr_text = "new superior not found";
+				goto return_results;
+			default:
+				Debug( LDAP_DEBUG_ANY,
+					   "<== wt_modrdn: wt_dn2entry failed %s (%d)\n",
+					   wiredtiger_strerror(rc), rc );
+				rs->sr_err = LDAP_OTHER;
+				rs->sr_text = "internal error";
+				goto return_results;
+			}
+			Debug( LDAP_DEBUG_TRACE,
+				   "wt_modrdn: wr to new parent OK np=%p, id=%ld\n",
+				   (void *) np, (long) np->e_id );
+			rs->sr_err = access_allowed( op, np, children,
+										 NULL, ACL_WADD, NULL );
+			if( ! rs->sr_err ) {
+				Debug( LDAP_DEBUG_TRACE,
+					   "wt_modrdn: no wr to newSup children\n" );
+				rs->sr_text = "no write access to new superior's children";
+				rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
+				goto return_results;
+			}
+			if ( is_entry_alias( np ) ) {
+				Debug( LDAP_DEBUG_TRACE,
+					   "wt_modrdn: entry is alias\n" );
+				rs->sr_text = "new superior is an alias";
+				rs->sr_err = LDAP_ALIAS_PROBLEM;
+				goto return_results;
+			}
+			if ( is_entry_referral( np ) ) {
+				/* parent is a referral, don't allow add */
+				Debug( LDAP_DEBUG_TRACE,
+					   "wt_modrdn: entry is referral\n" );
+				rs->sr_text = "new superior is a referral";
+				rs->sr_err = LDAP_OTHER;
+				goto return_results;
+			}
+		} else {
+			/* no parent, modrdn entry directly under root */
+			/* TODO: */
+			Debug( LDAP_DEBUG_TRACE,
+				   "wt_modrdn: no parent, not implement yet\n" );
+			rs->sr_text = "not implement yet";
+			rs->sr_err = LDAP_OTHER;
+			goto return_results;
+		}
+
+		Debug( LDAP_DEBUG_TRACE,
+			   "wt_modrdn: wr to new parent's children OK\n" );
+		new_parent_dn = np_dn;
+	}
+
+	/* Build target dn and make sure target entry doesn't exist already. */
+	if (!new_dn.bv_val) {
+		build_new_dn( &new_dn, new_parent_dn, &op->oq_modrdn.rs_newrdn, NULL );
+	}
+
+	if (!new_ndn.bv_val) {
+		struct berval bv = {0, NULL};
+		dnNormalize( 0, NULL, NULL, &new_dn, &bv, op->o_tmpmemctx );
+		ber_dupbv( &new_ndn, &bv );
+		/* FIXME: why not call dnNormalize() w/o ctx? */
+		op->o_tmpfree( bv.bv_val, op->o_tmpmemctx );
+	}
+
+	Debug( LDAP_DEBUG_TRACE,
+		   "wt_modrdn: new ndn=%s\n", new_ndn.bv_val );
+
+	/* check new entry */
+	rc = wt_dn2entry(op->o_bd, wc, &new_ndn, &ne);
+    switch( rc ) {
+	case 0:
+		/* Allow rename to same DN */
+		if(e->e_id == ne->e_id){
+			break;
+		}
+		rs->sr_err = LDAP_ALREADY_EXISTS;
+		goto return_results;
+		break;
+	case WT_NOTFOUND:
+		break;
+	default:
+		Debug( LDAP_DEBUG_ANY,
+			   "<== wt_modrdn: wt_dn2entry failed %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		rs->sr_err = LDAP_OTHER;
+		rs->sr_text = "internal error";
+		goto return_results;
+	}
+
+	assert( op->orr_modlist != NULL );
+
+	if( op->o_preread ) {
+		if( preread_ctrl == NULL ) {
+			preread_ctrl = &ctrls[num_ctrls++];
+			ctrls[num_ctrls] = NULL;
+		}
+		if( slap_read_controls( op, rs, e,
+								&slap_pre_read_bv, preread_ctrl ) )
+		{
+			Debug( LDAP_DEBUG_TRACE,
+				   "<== wt_modrdn: pre-read failed!\n" );
+			if ( op->o_preread & SLAP_CONTROL_CRITICAL ) {
+				/* FIXME: is it correct to abort
+				 * operation if control fails? */
+				goto return_results;
+			}
+		}
+	}
+
+	/* begin transaction */
+	rc = wc->session->begin_transaction(wc->session, NULL);
+	if( rc ) {
+		Debug( LDAP_DEBUG_TRACE,
+			   "wt_modrdn: begin_transaction failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		rs->sr_err = LDAP_OTHER;
+		rs->sr_text = "begin_transaction failed";
+		goto return_results;
+	}
+	wc->is_begin_transaction = 1;
+	Debug( LDAP_DEBUG_TRACE,
+		   "wt_modrdn: session id: %p\n", wc->session );
+
+	/* delete old DN */
+	rc = wt_dn2id_delete( op, wc, &e->e_nname);
+	if ( rc ) {
+		Debug(LDAP_DEBUG_TRACE,
+			  "<== wt_modrdn: delete failed: %s (%d)\n",
+			  wiredtiger_strerror(rc), rc );
+		rs->sr_err = LDAP_OTHER;
+		rs->sr_text = "dn2id delete failed";
+		goto return_results;
+	}
+
+	/* copy the entry, then override some fields */
+	dummy = *e;
+	dummy.e_name = new_dn;
+	dummy.e_nname = new_ndn;
+	dummy.e_attrs = NULL;
+
+	/* add new DN */
+	rc = wt_dn2id_add( op, wc, np?np->e_id:p->e_id, &dummy );
+	if ( rc ) {
+		Debug(LDAP_DEBUG_TRACE,
+			  "<== wt_modrdn: add failed: %s (%d)\n",
+			  wiredtiger_strerror(rc), rc );
+		rs->sr_err = LDAP_OTHER;
+		rs->sr_text = "DN add failed";
+		goto return_results;
+	}
+	dummy.e_attrs = e->e_attrs;
+
+	rc = wt_modify_internal( op, wc, op->orm_modlist,
+							 &dummy, &rs->sr_text, textbuf, textlen );
+	if( rc != LDAP_SUCCESS ) {
+		Debug(LDAP_DEBUG_TRACE,
+			  "<== wt_modrdn: modify failed: %s (%d)\n",
+			  wiredtiger_strerror(rc), rc );
+		if ( dummy.e_attrs == e->e_attrs ) dummy.e_attrs = NULL;
+		goto return_results;
+	}
+
+	/* update entry */
+	rc = wt_id2entry_update( op, wc, &dummy );
+	if ( rc != 0 ) {
+		Debug( LDAP_DEBUG_TRACE,
+			   "wt_modrdn: id2entry update failed(%d)\n", rc );
+		if ( rc == LDAP_ADMINLIMIT_EXCEEDED ) {
+			rs->sr_text = "entry too big";
+		} else {
+			rs->sr_err = LDAP_OTHER;
+			rs->sr_text = "entry update failed";
+		}
+		goto return_results;
+	}
+
+	if ( p_ndn.bv_len != 0 ) {
+		parent_is_glue = is_entry_glue(p);
+		/* TODO: glue entry handling */
+	}
+
+	if( op->o_postread ) {
+		if( postread_ctrl == NULL ) {
+			postread_ctrl = &ctrls[num_ctrls++];
+			ctrls[num_ctrls] = NULL;
+		}
+		if( slap_read_controls( op, rs, &dummy,
+								&slap_post_read_bv, postread_ctrl ) )
+		{
+			Debug( LDAP_DEBUG_TRACE,
+				   "<== wt_modrdn: post-read failed!\n" );
+			if ( op->o_postread & SLAP_CONTROL_CRITICAL ) {
+				/* FIXME: is it correct to abort
+				 * operation if control fails? */
+				goto return_results;
+			}
+		}
+	}
+
+	if( op->o_noop ) {
+		rs->sr_err = LDAP_X_NO_OPERATION;
+		goto return_results;
+	}
+
+	rc = wc->session->commit_transaction(wc->session, NULL);
+	wc->is_begin_transaction = 0;
+	if( rc ) {
+		Debug( LDAP_DEBUG_TRACE,
+			   "<== wt_modrdn: commit failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		rs->sr_err = LDAP_OTHER;
+		rs->sr_text = "commit failed";
+		goto return_results;
+	}
+
+	Debug(LDAP_DEBUG_TRACE,
+		  "wt_modrdn: rdn modified%s id=%08lx dn=\"%s\"\n",
+		  op->o_noop ? " (no-op)" : "",
+		  dummy.e_id, op->o_req_dn.bv_val );
+
+	rs->sr_err = LDAP_SUCCESS;
+	rs->sr_text = NULL;
+	if( num_ctrls ) rs->sr_ctrls = ctrls;
+
+return_results:
+	if ( dummy.e_attrs ) {
+		attrs_free( dummy.e_attrs );
+	}
+	send_ldap_result( op, rs );
+
+	if ( rs->sr_err == LDAP_SUCCESS && parent_is_glue && parent_is_leaf ) {
+		op->o_delete_glue_parent = 1;
+	}
+
+done:
+	if( wc && wc->is_begin_transaction ){
+		Debug( LDAP_DEBUG_TRACE, "wt_modrdn: rollback transaction\n" );
+		wc->session->rollback_transaction(wc->session, NULL);
+		wc->is_begin_transaction = 0;
+	}
+
+	slap_graduate_commit_csn( op );
+
+	if( new_dn.bv_val != NULL ) free( new_dn.bv_val );
+	if( new_ndn.bv_val != NULL ) free( new_ndn.bv_val );
+
+	/* free entry */
+	if( e != NULL ) {
+		wt_entry_return( e );
+	}
+	/* free parent entry */
+	if( p != NULL ) {
+		wt_entry_return( p );
+	}
+	/* free new entry */
+	if( ne != NULL ) {
+		wt_entry_return( ne );
+	}
+	/* free new parent entry */
+	if( np != NULL ) {
+		wt_entry_return( np );
+	}
+
+	if( preread_ctrl != NULL && (*preread_ctrl) != NULL ) {
+		slap_sl_free( (*preread_ctrl)->ldctl_value.bv_val, op->o_tmpmemctx );
+		slap_sl_free( *preread_ctrl, op->o_tmpmemctx );
+	}
+	if( postread_ctrl != NULL && (*postread_ctrl) != NULL ) {
+		slap_sl_free( (*postread_ctrl)->ldctl_value.bv_val, op->o_tmpmemctx );
+		slap_sl_free( *postread_ctrl, op->o_tmpmemctx );
+	}
+	return rs->sr_err;
+}
+
+/*
+ * Local variables:
+ * indent-tabs-mode: t
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */
diff --git a/servers/slapd/back-wt/nextid.c b/servers/slapd/back-wt/nextid.c
new file mode 100644
index 0000000..99620e9
--- /dev/null
+++ b/servers/slapd/back-wt/nextid.c
@@ -0,0 +1,88 @@
+/* OpenLDAP WiredTiger backend */
+/* $OpenLDAP$ */
+/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
+ *
+ * Copyright 2002-2022 The OpenLDAP Foundation.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted only as authorized by the OpenLDAP
+ * Public License.
+ *
+ * A copy of this license is available in the file LICENSE in the
+ * top-level directory of the distribution or, alternatively, at
+ * <http://www.OpenLDAP.org/license.html>.
+ */
+/* ACKNOWLEDGEMENTS:
+ * This work was developed by HAMANO Tsukasa <hamano@osstech.co.jp>
+ * based on back-bdb for inclusion in OpenLDAP Software.
+ * WiredTiger is a product of MongoDB Inc.
+ */
+
+#include "portable.h"
+
+#include <stdio.h>
+#include <ac/string.h>
+#include "back-wt.h"
+#include "slap-config.h"
+
+int wt_next_id(BackendDB *be, ID *out){
+    struct wt_info *wi = (struct wt_info *) be->be_private;
+	*out = __sync_add_and_fetch(&wi->wi_lastid, 1);
+	return 0;
+}
+
+int wt_last_id( BackendDB *be, WT_SESSION *session, ID *out )
+{
+    WT_CURSOR *cursor;
+    int rc;
+    uint64_t id;
+
+    rc = session->open_cursor(session, WT_TABLE_ID2ENTRY, NULL, NULL, &cursor);
+    if(rc){
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_last_id: open_cursor failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		return rc;
+    }
+
+    rc = cursor->prev(cursor);
+	switch(rc) {
+	case 0:
+		rc = cursor->get_key(cursor, &id);
+		if ( rc ) {
+			Debug( LDAP_DEBUG_ANY,
+				   "wt_last_id: get_key failed: %s (%d)\n",
+				   wiredtiger_strerror(rc), rc );
+			return rc;
+		}
+		*out = id;
+		break;
+	case WT_NOTFOUND:
+        /* no entry */
+        *out = 0;
+		break;
+	default:
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_last_id: prev failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+    }
+
+    rc = cursor->close(cursor);
+    if ( rc ) {
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_last_id: close failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		return rc;
+    }
+
+    return 0;
+}
+
+/*
+ * Local variables:
+ * indent-tabs-mode: t
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */
diff --git a/servers/slapd/back-wt/operational.c b/servers/slapd/back-wt/operational.c
new file mode 100644
index 0000000..df9d0c6
--- /dev/null
+++ b/servers/slapd/back-wt/operational.c
@@ -0,0 +1,110 @@
+/* OpenLDAP WiredTiger backend */
+/* $OpenLDAP$ */
+/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
+ *
+ * Copyright 2002-2022 The OpenLDAP Foundation.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted only as authorized by the OpenLDAP
+ * Public License.
+ *
+ * A copy of this license is available in the file LICENSE in the
+ * top-level directory of the distribution or, alternatively, at
+ * <http://www.OpenLDAP.org/license.html>.
+ */
+/* ACKNOWLEDGEMENTS:
+ * This work was developed by HAMANO Tsukasa <hamano@osstech.co.jp>
+ * based on back-bdb for inclusion in OpenLDAP Software.
+ * WiredTiger is a product of MongoDB Inc.
+ */
+
+#include "portable.h"
+
+#include <stdio.h>
+#include <ac/string.h>
+
+#include "back-wt.h"
+#include "slap-config.h"
+
+int
+wt_hasSubordinates(
+	Operation *op,
+	Entry *e,
+	int *hasSubordinates )
+{
+	struct wt_info *wi = (struct wt_info *) op->o_bd->be_private;
+	wt_ctx *wc = NULL;
+	int rc;
+
+	assert( e != NULL );
+
+	wc = wt_ctx_get(op, wi);
+	if( !wc ){
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_hasSubordinates: wt_ctx_get failed\n" );
+		return LDAP_OTHER;
+	}
+
+	rc = wt_dn2id_has_children(op, wc, e->e_id);
+	switch(rc){
+	case 0:
+		*hasSubordinates = LDAP_COMPARE_TRUE;
+		break;
+	case WT_NOTFOUND:
+		*hasSubordinates = LDAP_COMPARE_FALSE;
+		rc = LDAP_SUCCESS;
+		break;
+	default:
+		Debug(LDAP_DEBUG_ANY,
+			  "<=- wt_hasSubordinates: has_children failed: %s (%d)\n",
+			  wiredtiger_strerror(rc), rc );
+		rc = LDAP_OTHER;
+	}
+	return rc;
+}
+
+/*
+ * sets the supported operational attributes (if required)
+ */
+int
+wt_operational(
+	Operation *op,
+	SlapReply *rs )
+{
+	Attribute   **ap;
+
+	assert( rs->sr_entry != NULL );
+
+	for ( ap = &rs->sr_operational_attrs; *ap; ap = &(*ap)->a_next ) {
+		if ( (*ap)->a_desc == slap_schema.si_ad_hasSubordinates ) {
+			break;
+		}
+	}
+
+	if ( *ap == NULL &&
+		 attr_find( rs->sr_entry->e_attrs, slap_schema.si_ad_hasSubordinates ) == NULL &&
+		 ( SLAP_OPATTRS( rs->sr_attr_flags ) ||
+		   ad_inlist( slap_schema.si_ad_hasSubordinates, rs->sr_attrs ) ) )
+	{
+		int hasSubordinates, rc;
+
+		rc = wt_hasSubordinates( op, rs->sr_entry, &hasSubordinates );
+		if ( rc == LDAP_SUCCESS ) {
+			*ap = slap_operational_hasSubordinate( hasSubordinates == LDAP_COMPARE_TRUE );
+			assert( *ap != NULL );
+
+			ap = &(*ap)->a_next;
+		}
+	}
+
+	return LDAP_SUCCESS;
+}
+
+/*
+ * Local variables:
+ * indent-tabs-mode: t
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */
diff --git a/servers/slapd/back-wt/proto-wt.h b/servers/slapd/back-wt/proto-wt.h
new file mode 100644
index 0000000..7fa2666
--- /dev/null
+++ b/servers/slapd/back-wt/proto-wt.h
@@ -0,0 +1,268 @@
+/* OpenLDAP WiredTiger backend */
+/* $OpenLDAP$ */
+/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
+ *
+ * Copyright 2002-2022 The OpenLDAP Foundation.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted only as authorized by the OpenLDAP
+ * Public License.
+ *
+ * A copy of this license is available in the file LICENSE in the
+ * top-level directory of the distribution or, alternatively, at
+ * <http://www.OpenLDAP.org/license.html>.
+ */
+/* ACKNOWLEDGEMENTS:
+ * This work was developed by HAMANO Tsukasa <hamano@osstech.co.jp>
+ * based on back-bdb for inclusion in OpenLDAP Software.
+ * WiredTiger is a product of MongoDB Inc.
+ */
+
+#ifndef _PROTO_WT_H_
+#define _PROTO_WT_H_
+
+LDAP_BEGIN_DECL
+
+#define WT_UCTYPE  "WT"
+
+/*
+ * attr.c
+ */
+
+AttrInfo *wt_attr_mask( struct wt_info *wi, AttributeDescription *desc );
+void wt_attr_flush( struct wt_info *wi );
+void wt_attr_index_unparse( struct wt_info *wi, BerVarray *bva );
+int wt_attr_index_config(
+	struct wt_info  *wi,
+	const char      *fname,
+	int         lineno,
+	int         argc,
+	char        **argv,
+	struct      config_reply_s *c_reply);
+void wt_attr_index_destroy( struct wt_info *wi );
+
+/*
+ * id2entry.c
+ */
+int wt_id2entry(BackendDB *be, wt_ctx *wc, ID id, Entry **ep );
+int wt_id2entry_add(Operation *op, wt_ctx *wc, Entry *e );
+int wt_id2entry_update(Operation *op, wt_ctx *wc, Entry *e );
+int wt_id2entry_delete(Operation *op, wt_ctx *wc, Entry *e );
+
+BI_entry_release_rw wt_entry_release;
+BI_entry_get_rw wt_entry_get;
+
+int wt_entry_return(Entry *e);
+int wt_entry_release(Operation *op, Entry *e, int rw);
+
+/*
+ * idl.c
+ */
+
+unsigned wt_idl_search( ID *ids, ID id );
+
+ID wt_idl_first( ID *ids, ID *cursor );
+ID wt_idl_next( ID *ids, ID *cursor );
+int wt_idl_append_one( ID *ids, ID id );
+void wt_idl_sort( ID *ids, ID *tmp );
+int wt_idl_intersection( ID *a, ID *b );
+int wt_filter_candidates(
+	Operation *op,
+	wt_ctx *wc,
+	Filter *f,
+	ID *ids,
+	ID *tmp,
+	ID *stack );
+int
+wt_idl_union(
+	ID  *a,
+	ID  *b );
+
+/*
+ * index.c
+ */
+
+extern AttrInfo *
+wt_index_mask LDAP_P((
+	Backend *be,
+	AttributeDescription *desc,
+	struct berval *atname ));
+
+int wt_index_entry LDAP_P(( Operation *op, wt_ctx *wc, int r, Entry *e ));
+int wt_index_values(
+	Operation *op,
+	wt_ctx *wc,
+	AttributeDescription *desc,
+	BerVarray vals,
+	ID id,
+	int opid );
+int wt_index_param(
+	Backend *be,
+	AttributeDescription *desc,
+	int ftype,
+	slap_mask_t *maskp,
+	struct berval *prefixp );
+
+WT_CURSOR *wt_index_open(wt_ctx *wc, struct berval *name, int create);
+
+#define wt_index_entry_add(op,t,e) \
+	wt_index_entry((op),(t),SLAP_INDEX_ADD_OP,(e))
+#define wt_index_entry_del(op,t,e) \
+	wt_index_entry((op),(t),SLAP_INDEX_DELETE_OP,(e))
+
+/*
+ * key.c
+ */
+int
+wt_key_read( Backend *be,
+			 WT_CURSOR *cursor,
+			 struct berval *k,
+			 ID *ids,
+			 WT_CURSOR **saved_cursor,
+			 int get_flag);
+
+int
+wt_key_change( Backend *be,
+			   WT_CURSOR *cursor,
+			   struct berval *k,
+			   ID id,
+			   int op);
+
+/*
+ * nextid.c
+ */
+int wt_next_id(BackendDB *be, ID *out);
+int wt_last_id( BackendDB *be, WT_SESSION *session, ID *out );
+
+/*
+ * modify.c
+ */
+int wt_modify_internal(
+	Operation *op,
+	wt_ctx *wc,
+	Modifications *modlist,
+	Entry *e,
+	const char **text,
+	char *textbuf,
+	size_t textlen );
+
+/*
+ * config.c
+ */
+int wt_back_init_cf( BackendInfo *bi );
+
+/*
+ * dn2id.c
+ */
+
+int
+wt_dn2id(
+	Operation *op,
+	wt_ctx *wc,
+    struct berval *ndn,
+    ID *id);
+
+int
+wt_dn2id_add(
+	Operation *op,
+	wt_ctx *wc,
+	ID pid,
+	Entry *e);
+
+int
+wt_dn2idl(
+	Operation *op,
+	wt_ctx *wc,
+	struct berval *ndn,
+	Entry *e,
+	ID *ids,
+	ID *stack);
+
+int
+wt_dn2id_delete(
+	Operation *op,
+	wt_ctx *wc,
+	struct berval *ndn);
+
+int
+wt_dn2id_has_children(
+	Operation *op,
+	wt_ctx *wc,
+	ID id );
+
+/*
+ * dn2entry.c
+ */
+int wt_dn2entry( BackendDB *be,
+				 wt_ctx *wc,
+				 struct berval *ndn,
+				 Entry **ep );
+
+int wt_dn2pentry( BackendDB *be,
+				  wt_ctx *wc,
+				  struct berval *ndn,
+				  Entry **ep );
+int wt_dn2aentry( BackendDB *be,
+				  wt_ctx *wc,
+				  struct berval *ndn,
+				  Entry **ep );
+
+/*
+ * former ctx.c
+ */
+wt_ctx *wt_ctx_init(struct wt_info *wi);
+void wt_ctx_free(void *key, void *data);
+wt_ctx *wt_ctx_get(Operation *op, struct wt_info *wi);
+
+/*
+ * former cache.c
+ */
+int wt_idlcache_get(wt_ctx *wc, struct berval *ndn, int scope, ID *ids);
+int wt_idlcache_set(wt_ctx *wc, struct berval *ndn, int scope, ID *ids);
+int wt_idlcache_begin(wt_ctx *wc, struct berval *ndn, int scope);
+int wt_idlcache_clear(Operation *op, wt_ctx *wc, struct berval *ndn);
+
+/*
+ * former external.h
+ */
+
+extern BI_init              wt_back_initialize;
+extern BI_db_config         wt_db_config;
+extern BI_op_add            wt_add;
+extern BI_op_bind           wt_bind;
+extern BI_op_compare        wt_compare;
+extern BI_op_delete         wt_delete;
+extern BI_op_modify         wt_modify;
+extern BI_op_modrdn         wt_modrdn;
+extern BI_op_search         wt_search;
+extern BI_op_extended       wt_extended;
+
+extern BI_operational       wt_operational;
+extern BI_has_subordinates  wt_hasSubordinates;
+
+/* tools.c */
+int wt_entry_header(WT_ITEM *item, EntryHeader *eh);
+extern BI_tool_entry_open    wt_tool_entry_open;
+extern BI_tool_entry_close   wt_tool_entry_close;
+extern BI_tool_entry_first_x wt_tool_entry_first_x;
+extern BI_tool_entry_next    wt_tool_entry_next;
+extern BI_tool_entry_get     wt_tool_entry_get;
+extern BI_tool_entry_put     wt_tool_entry_put;
+extern BI_tool_entry_reindex wt_tool_entry_reindex;
+extern BI_tool_dn2id_get     wt_tool_dn2id_get;
+extern BI_tool_entry_modify  wt_tool_entry_modify;
+extern BI_tool_entry_delete  wt_tool_entry_delete;
+
+LDAP_END_DECL
+
+#endif /* _PROTO_WT_H */
+
+/*
+ * Local variables:
+ * indent-tabs-mode: t
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */
+
diff --git a/servers/slapd/back-wt/search.c b/servers/slapd/back-wt/search.c
new file mode 100644
index 0000000..8a313b3
--- /dev/null
+++ b/servers/slapd/back-wt/search.c
@@ -0,0 +1,759 @@
+/* OpenLDAP WiredTiger backend */
+/* $OpenLDAP$ */
+/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
+ *
+ * Copyright 2002-2022 The OpenLDAP Foundation.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted only as authorized by the OpenLDAP
+ * Public License.
+ *
+ * A copy of this license is available in the file LICENSE in the
+ * top-level directory of the distribution or, alternatively, at
+ * <http://www.OpenLDAP.org/license.html>.
+ */
+/* ACKNOWLEDGEMENTS:
+ * This work was developed by HAMANO Tsukasa <hamano@osstech.co.jp>
+ * based on back-bdb for inclusion in OpenLDAP Software.
+ * WiredTiger is a product of MongoDB Inc.
+ */
+
+#include "portable.h"
+
+#include <stdio.h>
+#include <ac/string.h>
+
+#include "back-wt.h"
+#include "idl.h"
+
+static int search_aliases(
+	Operation *op,
+	SlapReply *rs,
+	Entry *e,
+	WT_SESSION *session,
+	ID *ids,
+	ID *scopes,
+	ID *stack )
+{
+	/* TODO: search_aliases does not implement yet. */
+	WT_IDL_ZERO( ids );
+	return 0;
+}
+
+static int base_candidate(
+	BackendDB *be,
+	Entry *e,
+	ID *ids )
+{
+	Debug(LDAP_DEBUG_ARGS,
+		  "base_candidate: base: \"%s\" (0x%08lx)\n",
+		  e->e_nname.bv_val, (long) e->e_id );
+
+	ids[0] = 1;
+	ids[1] = e->e_id;
+	return 0;
+}
+
+/* Look for "objectClass Present" in this filter.
+ * Also count depth of filter tree while we're at it.
+ */
+static int oc_filter(
+	Filter *f,
+	int cur,
+	int *max )
+{
+	int rc = 0;
+
+	assert( f != NULL );
+
+	if( cur > *max ) *max = cur;
+
+	switch( f->f_choice ) {
+	case LDAP_FILTER_PRESENT:
+		if (f->f_desc == slap_schema.si_ad_objectClass) {
+			rc = 1;
+		}
+		break;
+
+	case LDAP_FILTER_AND:
+	case LDAP_FILTER_OR:
+		cur++;
+		for ( f=f->f_and; f; f=f->f_next ) {
+			(void) oc_filter(f, cur, max);
+		}
+		break;
+
+	default:
+		break;
+	}
+	return rc;
+}
+
+static void search_stack_free( void *key, void *data )
+{
+	ber_memfree_x(data, NULL);
+}
+
+static void *search_stack( Operation *op )
+{
+	struct wt_info *wi = (struct wt_info *) op->o_bd->be_private;
+	void *ret = NULL;
+
+	if ( op->o_threadctx ) {
+		ldap_pvt_thread_pool_getkey( op->o_threadctx, (void *)search_stack,
+									 &ret, NULL );
+	} else {
+		ret = wi->wi_search_stack;
+	}
+
+	if ( !ret ) {
+		ret = ch_malloc( wi->wi_search_stack_depth * WT_IDL_UM_SIZE
+						 * sizeof( ID ) );
+		if ( op->o_threadctx ) {
+			ldap_pvt_thread_pool_setkey( op->o_threadctx, (void *)search_stack,
+										 ret, search_stack_free, NULL, NULL );
+		} else {
+			wi->wi_search_stack = ret;
+		}
+	}
+	return ret;
+}
+
+static int search_candidates(
+	Operation *op,
+	SlapReply *rs,
+	Entry *e,
+	wt_ctx *wc,
+	ID  *ids,
+	ID  *scopes )
+{
+    struct wt_info *wi = (struct wt_info *) op->o_bd->be_private;
+	int rc, depth = 1;
+	Filter f, rf, xf, nf;
+	ID *stack;
+	AttributeAssertion aa_ref = ATTRIBUTEASSERTION_INIT;
+	Filter sf;
+	AttributeAssertion aa_subentry = ATTRIBUTEASSERTION_INIT;
+
+	Debug(LDAP_DEBUG_TRACE,
+		  "wt_search_candidates: base=\"%s\" (0x%08lx) scope=%d\n",
+		  e->e_nname.bv_val, (long) e->e_id, op->oq_search.rs_scope );
+
+	xf.f_or = op->oq_search.rs_filter;
+	xf.f_choice = LDAP_FILTER_OR;
+	xf.f_next = NULL;
+
+	/* If the user's filter uses objectClass=*,
+     * these clauses are redundant.
+     */
+	if (!oc_filter(op->oq_search.rs_filter, 1, &depth)
+		&& !get_subentries_visibility(op)) {
+		if( !get_manageDSAit(op) && !get_domainScope(op) ) {
+			/* match referral objects */
+			struct berval bv_ref = BER_BVC( "referral" );
+			rf.f_choice = LDAP_FILTER_EQUALITY;
+			rf.f_ava = &aa_ref;
+			rf.f_av_desc = slap_schema.si_ad_objectClass;
+			rf.f_av_value = bv_ref;
+			rf.f_next = xf.f_or;
+			xf.f_or = &rf;
+			depth++;
+		}
+	}
+
+	f.f_next = NULL;
+	f.f_choice = LDAP_FILTER_AND;
+	f.f_and = &nf;
+	/* Dummy; we compute scope separately now */
+	nf.f_choice = SLAPD_FILTER_COMPUTED;
+	nf.f_result = LDAP_SUCCESS;
+	nf.f_next = ( xf.f_or == op->oq_search.rs_filter )
+		? op->oq_search.rs_filter : &xf ;
+	/* Filter depth increased again, adding dummy clause */
+	depth++;
+
+	if( get_subentries_visibility( op ) ) {
+		struct berval bv_subentry = BER_BVC( "subentry" );
+		sf.f_choice = LDAP_FILTER_EQUALITY;
+		sf.f_ava = &aa_subentry;
+		sf.f_av_desc = slap_schema.si_ad_objectClass;
+		sf.f_av_value = bv_subentry;
+		sf.f_next = nf.f_next;
+		nf.f_next = &sf;
+	}
+
+	/* Allocate IDL stack, plus 1 more for former tmp */
+	if ( depth+1 > wi->wi_search_stack_depth ) {
+		stack = ch_malloc( (depth + 1) * WT_IDL_UM_SIZE * sizeof( ID ) );
+	} else {
+		stack = search_stack( op );
+	}
+
+    if( op->ors_deref & LDAP_DEREF_SEARCHING ) {
+		rc = search_aliases( op, rs, e, wc->session, ids, scopes, stack );
+		if ( WT_IDL_IS_ZERO( ids ) && rc == LDAP_SUCCESS )
+			rc = wt_dn2idl( op, wc, &e->e_nname, e, ids, stack );
+	} else {
+		rc = wt_dn2idl(op, wc, &e->e_nname, e, ids, stack );
+	}
+
+	if ( rc == LDAP_SUCCESS ) {
+		rc = wt_filter_candidates( op, wc, &f, ids,
+								   stack, stack+WT_IDL_UM_SIZE );
+	}
+
+	if ( depth+1 > wi->wi_search_stack_depth ) {
+		ch_free( stack );
+	}
+
+    if( rc ) {
+		Debug(LDAP_DEBUG_TRACE,
+			  "wt_search_candidates: failed (rc=%d)\n", rc );
+
+	} else {
+		Debug(LDAP_DEBUG_TRACE,
+			  "wt_search_candidates: id=%ld first=%ld last=%ld\n",
+			  (long) ids[0],
+			  (long) WT_IDL_FIRST(ids),
+			  (long) WT_IDL_LAST(ids));
+	}
+	return 0;
+}
+
+static int
+parse_paged_cookie( Operation *op, SlapReply *rs )
+{
+	int     rc = LDAP_SUCCESS;
+	PagedResultsState *ps = op->o_pagedresults_state;
+
+	/* this function must be invoked only if the pagedResults
+     * control has been detected, parsed and partially checked
+     * by the frontend */
+	assert( get_pagedresults( op ) > SLAP_CONTROL_IGNORED );
+
+	/* cookie decoding/checks deferred to backend... */
+	if ( ps->ps_cookieval.bv_len ) {
+		PagedResultsCookie reqcookie;
+		if( ps->ps_cookieval.bv_len != sizeof( reqcookie ) ) {
+			/* bad cookie */
+			rs->sr_text = "paged results cookie is invalid";
+			rc = LDAP_PROTOCOL_ERROR;
+			goto done;
+		}
+
+		memcpy( &reqcookie, ps->ps_cookieval.bv_val, sizeof( reqcookie ));
+
+		if ( reqcookie > ps->ps_cookie ) {
+			/* bad cookie */
+			rs->sr_text = "paged results cookie is invalid";
+			rc = LDAP_PROTOCOL_ERROR;
+			goto done;
+
+		} else if ( reqcookie < ps->ps_cookie ) {
+			rs->sr_text = "paged results cookie is invalid or old";
+			rc = LDAP_UNWILLING_TO_PERFORM;
+			goto done;
+		}
+
+	} else {
+		/* we're going to use ps_cookie */
+		op->o_conn->c_pagedresults_state.ps_cookie = 0;
+	}
+
+done:;
+
+	return rc;
+}
+
+static void
+send_paged_response(
+	Operation   *op,
+	SlapReply   *rs,
+	ID      *lastid,
+	int     tentries )
+{
+	LDAPControl *ctrls[2];
+	BerElementBuffer berbuf;
+	BerElement  *ber = (BerElement *)&berbuf;
+	PagedResultsCookie respcookie;
+	struct berval cookie;
+
+	Debug(LDAP_DEBUG_ARGS,
+		  "send_paged_response: lastid=0x%08lx nentries=%d\n",
+		  lastid ? *lastid : 0, rs->sr_nentries );
+
+	ctrls[1] = NULL;
+
+	ber_init2( ber, NULL, LBER_USE_DER );
+
+	if ( lastid ) {
+		respcookie = ( PagedResultsCookie )(*lastid);
+		cookie.bv_len = sizeof( respcookie );
+		cookie.bv_val = (char *)&respcookie;
+
+	} else {
+		respcookie = ( PagedResultsCookie )0;
+		BER_BVSTR( &cookie, "" );
+	}
+
+	op->o_conn->c_pagedresults_state.ps_cookie = respcookie;
+	op->o_conn->c_pagedresults_state.ps_count =
+		((PagedResultsState *)op->o_pagedresults_state)->ps_count +
+		rs->sr_nentries;
+
+	/* return size of 0 -- no estimate */
+	ber_printf( ber, "{iO}", 0, &cookie );
+
+	ctrls[0] = op->o_tmpalloc( sizeof(LDAPControl), op->o_tmpmemctx );
+	if ( ber_flatten2( ber, &ctrls[0]->ldctl_value, 0 ) == -1 ) {
+		goto done;
+	}
+
+	ctrls[0]->ldctl_oid = LDAP_CONTROL_PAGEDRESULTS;
+	ctrls[0]->ldctl_iscritical = 0;
+
+	slap_add_ctrls( op, rs, ctrls );
+	rs->sr_err = LDAP_SUCCESS;
+	send_ldap_result( op, rs );
+
+done:
+	(void) ber_free_buf( ber );
+}
+
+int
+wt_search( Operation *op, SlapReply *rs )
+{
+    struct wt_info *wi = (struct wt_info *) op->o_bd->be_private;
+	ID id, cursor;
+	ID lastid = NOID;
+	int manageDSAit;
+	wt_ctx *wc;
+	int rc = LDAP_OTHER;
+	Entry *e = NULL;
+	Entry *ae = NULL;
+	Entry *base = NULL;
+	slap_mask_t mask;
+	time_t stoptime;
+
+	ID candidates[WT_IDL_UM_SIZE];
+	ID scopes[WT_IDL_DB_SIZE];
+	int tentries = 0;
+	unsigned nentries = 0;
+
+	Debug( LDAP_DEBUG_ARGS, "==> wt_search: %s\n", op->o_req_dn.bv_val );
+
+	manageDSAit = get_manageDSAit( op );
+
+	wc = wt_ctx_get(op, wi);
+	if( !wc ){
+        Debug( LDAP_DEBUG_ANY,
+			   "wt_search: wt_ctx_get failed: %d\n", rc );
+		send_ldap_error( op, rs, LDAP_OTHER, "internal error" );
+        return rc;
+	}
+
+	/* get entry */
+	rc = wt_dn2entry(op->o_bd, wc, &op->o_req_ndn, &e);
+	switch( rc ) {
+	case 0:
+		break;
+	case WT_NOTFOUND:
+		rc = wt_dn2aentry(op->o_bd, wc, &op->o_req_ndn, &ae);
+		break;
+	default:
+		/* TODO: error handling */
+		Debug( LDAP_DEBUG_ANY,
+			   "<== wt_search: error at wt_dn2entry() rc=%d\n", rc );
+		send_ldap_error( op, rs, LDAP_OTHER, "internal error" );
+		goto done;
+	}
+
+	if ( op->ors_deref & LDAP_DEREF_FINDING ) {
+		/* not implement yet */
+	}
+
+	if ( e == NULL ) {
+		if ( ae ) {
+			struct berval matched_dn = BER_BVNULL;
+			/* found ancestor entry */
+			if ( access_allowed( op, ae,
+								 slap_schema.si_ad_entry,
+								 NULL, ACL_DISCLOSE, NULL ) ) {
+				BerVarray erefs = NULL;
+				ber_dupbv( &matched_dn, &ae->e_name );
+				erefs = is_entry_referral( ae )
+					? get_entry_referrals( op, ae )
+					: NULL;
+				rs->sr_err = LDAP_REFERRAL;
+				rs->sr_matched = matched_dn.bv_val;
+				if ( erefs ) {
+					rs->sr_ref = referral_rewrite( erefs, &matched_dn,
+												   &op->o_req_dn, op->oq_search.rs_scope );
+					ber_bvarray_free( erefs );
+				}
+				Debug( LDAP_DEBUG_ARGS,
+					   "wt_search: ancestor is referral\n");
+				rs->sr_flags = REP_MATCHED_MUSTBEFREED | REP_REF_MUSTBEFREED;
+				send_ldap_result( op, rs );
+				goto done;
+			}
+		}
+		Debug( LDAP_DEBUG_ARGS,
+			   "wt_search: no such object %s\n",
+			   op->o_req_dn.bv_val);
+		rs->sr_err = LDAP_NO_SUCH_OBJECT;
+		send_ldap_result( op, rs );
+		goto done;
+	}
+
+	/* NOTE: __NEW__ "search" access is required
+     * on searchBase object */
+	if ( ! access_allowed_mask( op, e, slap_schema.si_ad_entry,
+								NULL, ACL_SEARCH, NULL, &mask ) )
+	{
+		if ( !ACL_GRANT( mask, ACL_DISCLOSE ) ) {
+			rs->sr_err = LDAP_NO_SUCH_OBJECT;
+		} else {
+			rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
+		}
+
+		send_ldap_result( op, rs );
+		goto done;
+	}
+
+	if ( !manageDSAit && is_entry_referral( e ) ) {
+		struct berval matched_dn = BER_BVNULL;
+		BerVarray erefs = NULL;
+		ber_dupbv( &matched_dn, &e->e_name );
+		erefs = get_entry_referrals( op, e );
+		rs->sr_err = LDAP_REFERRAL;
+		if ( erefs ) {
+			rs->sr_ref = referral_rewrite( erefs, &matched_dn,
+										   &op->o_req_dn, op->oq_search.rs_scope );
+			ber_bvarray_free( erefs );
+			if ( !rs->sr_ref ) {
+				rs->sr_text = "bad_referral object";
+			}
+		}
+		Debug( LDAP_DEBUG_ARGS, "wt_search: entry is referral\n");
+		rs->sr_matched = matched_dn.bv_val;
+		send_ldap_result( op, rs );
+		ber_bvarray_free( rs->sr_ref );
+		rs->sr_ref = NULL;
+		ber_memfree( matched_dn.bv_val );
+		rs->sr_matched = NULL;
+		goto done;
+	}
+
+	if ( get_assert( op ) &&
+		 ( test_filter( op, e, get_assertion( op )) != LDAP_COMPARE_TRUE ))
+	{
+		rs->sr_err = LDAP_ASSERTION_FAILED;
+		send_ldap_result( op, rs );
+		goto done;
+	}
+
+	/* compute it anyway; root does not use it */
+	stoptime = op->o_time + op->ors_tlimit;
+
+	base = e;
+
+	e = NULL;
+
+	/* select candidates */
+	if ( op->oq_search.rs_scope == LDAP_SCOPE_BASE ) {
+		rs->sr_err = base_candidate( op->o_bd, base, candidates );
+	}else{
+		WT_IDL_ZERO( candidates );
+		WT_IDL_ZERO( scopes );
+		rc = search_candidates( op, rs, base,
+								wc, candidates, scopes );
+		switch(rc){
+		case 0:
+		case WT_NOTFOUND:
+			break;
+		default:
+			Debug( LDAP_DEBUG_ANY, "wt_search: error search_candidates\n" );
+			send_ldap_error( op, rs, LDAP_OTHER, "internal error" );
+			goto done;
+		}
+	}
+
+	/* start cursor at beginning of candidates.
+     */
+	cursor = 0;
+
+	if ( candidates[0] == 0 ) {
+		Debug( LDAP_DEBUG_TRACE, "wt_search: no candidates\n" );
+		goto nochange;
+	}
+
+	if ( op->ors_limit &&
+		 op->ors_limit->lms_s_unchecked != -1 &&
+		 WT_IDL_N(candidates) > (unsigned) op->ors_limit->lms_s_unchecked )
+	{
+		rs->sr_err = LDAP_ADMINLIMIT_EXCEEDED;
+		send_ldap_result( op, rs );
+		rs->sr_err = LDAP_SUCCESS;
+		goto done;
+	}
+
+	if ( op->ors_limit == NULL  /* isroot == TRUE */ ||
+		 !op->ors_limit->lms_s_pr_hide )
+	{
+		tentries = WT_IDL_N(candidates);
+	}
+
+	if ( get_pagedresults( op ) > SLAP_CONTROL_IGNORED ) {
+		/* TODO: pageresult */
+		PagedResultsState *ps = op->o_pagedresults_state;
+		/* deferred cookie parsing */
+		rs->sr_err = parse_paged_cookie( op, rs );
+		if ( rs->sr_err != LDAP_SUCCESS ) {
+			send_ldap_result( op, rs );
+			goto done;
+		}
+
+		cursor = (ID) ps->ps_cookie;
+		if ( cursor && ps->ps_size == 0 ) {
+			rs->sr_err = LDAP_SUCCESS;
+			rs->sr_text = "search abandoned by pagedResult size=0";
+			send_ldap_result( op, rs );
+			goto done;
+		}
+		id = wt_idl_first( candidates, &cursor );
+		if ( id == NOID ) {
+			Debug( LDAP_DEBUG_TRACE, "wt_search: no paged results candidates\n" );
+			send_paged_response( op, rs, &lastid, 0 );
+
+			rs->sr_err = LDAP_OTHER;
+			goto done;
+		}
+		nentries = ps->ps_count;
+		if ( id == (ID)ps->ps_cookie )
+			id = wt_idl_next( candidates, &cursor );
+		goto loop_begin;
+	}
+
+	for ( id = wt_idl_first( candidates, &cursor );
+		  id != NOID ; id = wt_idl_next( candidates, &cursor ) )
+	{
+		int scopeok;
+
+loop_begin:
+
+		/* check for abandon */
+		if ( op->o_abandon ) {
+			rs->sr_err = SLAPD_ABANDON;
+			send_ldap_result( op, rs );
+			goto done;
+		}
+
+		/* mostly needed by internal searches,
+         * e.g. related to syncrepl, for whom
+         * abandon does not get set... */
+		if ( slapd_shutdown ) {
+			rs->sr_err = LDAP_UNAVAILABLE;
+			send_ldap_disconnect( op, rs );
+			goto done;
+		}
+
+		/* check time limit */
+		if ( op->ors_tlimit != SLAP_NO_LIMIT
+			 && slap_get_time() > stoptime )
+		{
+			rs->sr_err = LDAP_TIMELIMIT_EXCEEDED;
+			rs->sr_ref = rs->sr_v2ref;
+			send_ldap_result( op, rs );
+			rs->sr_err = LDAP_SUCCESS;
+			goto done;
+		}
+
+		nentries++;
+
+	fetch_entry_retry:
+
+		rc = wt_id2entry(op->o_bd, wc, id, &e);
+		/* TODO: error handling */
+		if ( e == NULL ) {
+			/* TODO: */
+			goto loop_continue;
+		}
+		if ( is_entry_subentry( e ) ) {
+            if( op->oq_search.rs_scope != LDAP_SCOPE_BASE ) {
+				if(!get_subentries_visibility( op )) {
+					/* only subentries are visible */
+					goto loop_continue;
+				}
+
+			} else if ( get_subentries( op ) &&
+						!get_subentries_visibility( op ))
+			{
+				/* only subentries are visible */
+				goto loop_continue;
+			}
+
+		} else if ( get_subentries_visibility( op )) {
+			/* only subentries are visible */
+			goto loop_continue;
+		}
+
+		scopeok = 0;
+		switch( op->ors_scope ) {
+		case LDAP_SCOPE_BASE:
+			/* This is always true, yes? */
+			if ( id == base->e_id ) scopeok = 1;
+			break;
+		case LDAP_SCOPE_ONELEVEL:
+			scopeok = 1;
+			break;
+		case LDAP_SCOPE_CHILDREN:
+			if ( id == base->e_id ) break;
+			/* Fall-thru */
+		case LDAP_SCOPE_SUBTREE:
+ 			scopeok = dnIsSuffix(&e->e_nname, &base->e_nname);
+			break;
+		}
+
+		/* aliases were already dereferenced in candidate list */
+		if ( op->ors_deref & LDAP_DEREF_SEARCHING ) {
+			/* but if the search base is an alias, and we didn't
+			 * deref it when finding, return it.
+			 */
+			if ( is_entry_alias(e) &&
+				 ((op->ors_deref & LDAP_DEREF_FINDING) ||
+				  !bvmatch(&e->e_nname, &op->o_req_ndn)))
+			{
+				goto loop_continue;
+			}
+			/* TODO: alias handling */
+		}
+
+		/* Not in scope, ignore it */
+		if ( !scopeok )
+		{
+			Debug( LDAP_DEBUG_TRACE, "wt_search: %ld scope not okay\n",
+				   (long) id );
+			goto loop_continue;
+		}
+
+		/*
+         * if it's a referral, add it to the list of referrals. only do
+         * this for non-base searches, and don't check the filter
+         * explicitly here since it's only a candidate anyway.
+         */
+		if ( !manageDSAit && op->oq_search.rs_scope != LDAP_SCOPE_BASE
+			 && is_entry_referral( e ) )
+		{
+			BerVarray erefs = get_entry_referrals( op, e );
+			rs->sr_ref = referral_rewrite( erefs, &e->e_name, NULL,
+										   op->oq_search.rs_scope == LDAP_SCOPE_ONELEVEL
+										   ? LDAP_SCOPE_BASE : LDAP_SCOPE_SUBTREE );
+			rs->sr_entry = e;
+			send_search_reference( op, rs );
+			rs->sr_entry = NULL;
+			ber_bvarray_free( rs->sr_ref );
+			ber_bvarray_free( erefs );
+			goto loop_continue;
+		}
+
+		if ( !manageDSAit && is_entry_glue( e )) {
+			goto loop_continue;
+		}
+
+		/* if it matches the filter and scope, send it */
+		rs->sr_err = test_filter( op, e, op->oq_search.rs_filter );
+		if ( rs->sr_err == LDAP_COMPARE_TRUE ) {
+			/* check size limit */
+			if ( get_pagedresults(op) > SLAP_CONTROL_IGNORED ) {
+				if ( rs->sr_nentries >= ((PagedResultsState *)op->o_pagedresults_state)->ps_size ) {
+					wt_entry_return( e );
+					e = NULL;
+					send_paged_response( op, rs, &lastid, tentries );
+					goto done;
+				}
+				lastid = id;
+			}
+
+			if (e) {
+				/* safe default */
+				rs->sr_attrs = op->oq_search.rs_attrs;
+				rs->sr_operational_attrs = NULL;
+				rs->sr_ctrls = NULL;
+				rs->sr_entry = e;
+				RS_ASSERT( e->e_private != NULL );
+				rs->sr_flags = REP_ENTRY_MUSTRELEASE;
+				rs->sr_err = LDAP_SUCCESS;
+				rs->sr_err = send_search_entry( op, rs );
+				rs->sr_attrs = NULL;
+				rs->sr_entry = NULL;
+				e = NULL;
+
+				switch ( rs->sr_err ) {
+				case LDAP_SUCCESS:  /* entry sent ok */
+					break;
+				default: /* entry not sent */
+					break;
+				case LDAP_BUSY:
+					send_ldap_result( op, rs );
+					goto done;
+				case LDAP_UNAVAILABLE:
+					rs->sr_err = LDAP_OTHER;
+					goto done;
+				case LDAP_SIZELIMIT_EXCEEDED:
+					rs->sr_ref = rs->sr_v2ref;
+					send_ldap_result( op, rs );
+					rs->sr_err = LDAP_SUCCESS;
+					goto done;
+				}
+			}
+		} else {
+			Debug( LDAP_DEBUG_TRACE,
+				   "wt_search: %ld does not match filter\n", (long) id );
+		}
+
+	loop_continue:
+		if( e ) {
+			wt_entry_return( e );
+			e = NULL;
+		}
+	}
+
+nochange:
+    rs->sr_ctrls = NULL;
+	rs->sr_ref = rs->sr_v2ref;
+	rs->sr_err = (rs->sr_v2ref == NULL) ? LDAP_SUCCESS : LDAP_REFERRAL;
+	rs->sr_rspoid = NULL;
+	if ( get_pagedresults(op) > SLAP_CONTROL_IGNORED ) {
+		send_paged_response( op, rs, NULL, 0 );
+	} else {
+		send_ldap_result( op, rs );
+	}
+
+	rs->sr_err = LDAP_SUCCESS;
+
+done:
+
+	if( base ) {
+		wt_entry_return( base );
+	}
+
+	if( e ) {
+		wt_entry_return( e );
+	}
+
+	if( ae ) {
+		wt_entry_return( ae );
+	}
+
+    return rs->sr_err;
+}
+
+/*
+ * Local variables:
+ * indent-tabs-mode: t
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */
diff --git a/servers/slapd/back-wt/tools.c b/servers/slapd/back-wt/tools.c
new file mode 100644
index 0000000..795e81d
--- /dev/null
+++ b/servers/slapd/back-wt/tools.c
@@ -0,0 +1,721 @@
+/* OpenLDAP WiredTiger backend */
+/* $OpenLDAP$ */
+/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
+ *
+ * Copyright 2002-2022 The OpenLDAP Foundation.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted only as authorized by the OpenLDAP
+ * Public License.
+ *
+ * A copy of this license is available in the file LICENSE in the
+ * top-level directory of the distribution or, alternatively, at
+ * <http://www.OpenLDAP.org/license.html>.
+ */
+/* ACKNOWLEDGEMENTS:
+ * This work was developed by HAMANO Tsukasa <hamano@osstech.co.jp>
+ * based on back-bdb for inclusion in OpenLDAP Software.
+ * WiredTiger is a product of MongoDB Inc.
+ */
+
+#include "portable.h"
+
+#include <stdio.h>
+#include <ac/string.h>
+#include "back-wt.h"
+#include "slap-config.h"
+
+typedef struct dn_id {
+    ID id;
+    struct berval dn;
+} dn_id;
+
+#define HOLE_SIZE   4096
+static dn_id hbuf[HOLE_SIZE], *holes = hbuf;
+static unsigned nholes;
+
+static struct berval    *tool_base;
+static int      tool_scope;
+static Filter       *tool_filter;
+
+static wt_ctx *wc;
+static WT_CURSOR *reader;
+static WT_ITEM item;
+
+int
+wt_tool_entry_open( BackendDB *be, int mode )
+{
+    struct wt_info *wi = (struct wt_info *) be->be_private;
+	int rc;
+
+	if ( slapMode & SLAP_TOOL_DRYRUN )
+		return 0;
+
+	wc = wt_ctx_init(wi);
+    if( !wc ){
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_tool_entry_open: wt_ctx_get failed\n" );
+		return -1;
+    }
+
+	rc = wc->session->open_cursor(wc->session, WT_TABLE_ID2ENTRY"(entry)"
+								  ,NULL, NULL, &reader);
+	if ( rc ) {
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_tool_entry_open: cursor open failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		return -1;
+	}
+
+	return 0;
+}
+
+int
+wt_tool_entry_close( BackendDB *be )
+{
+	if ( slapMode & SLAP_TOOL_DRYRUN )
+		return 0;
+
+	if( reader ) {
+		reader->close(reader);
+		reader = NULL;
+	}
+
+	wt_ctx_free(NULL, wc);
+
+    if( nholes ) {
+        unsigned i;
+        fprintf( stderr, "Error, entries missing!\n");
+        for (i=0; i<nholes; i++) {
+            fprintf(stderr, "  entry %ld: %s\n",
+					holes[i].id, holes[i].dn.bv_val);
+        }
+        return -1;
+    }
+
+	return 0;
+}
+
+ID
+wt_tool_entry_first_x( BackendDB *be,
+					   struct berval *base,
+					   int scope,
+					   Filter *f )
+{
+	tool_base = base;
+	tool_scope = scope;
+	tool_filter = f;
+
+	return wt_tool_entry_next( be );
+}
+
+ID
+wt_tool_entry_next( BackendDB *be )
+{
+	int rc;
+	ID id;
+
+	rc = reader->next(reader);
+	switch( rc ){
+	case 0:
+		break;
+	case WT_NOTFOUND:
+		return NOID;
+	default:
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_tool_entry_next: next failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		return NOID;
+	}
+
+	rc = reader->get_key(reader, &id);
+	if( rc ){
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_tool_entry_next: get_key failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+	}
+	return id;
+}
+
+static ber_len_t
+entry_getlen(unsigned char **buf)
+{
+    ber_len_t len;
+    int i;
+
+    len = *(*buf)++;
+    if (len <= 0x7f)
+        return len;
+    i = len & 0x7f;
+    len = 0;
+    for (;i > 0; i--) {
+        len <<= 8;
+        len |= *(*buf)++;
+    }
+    return len;
+}
+
+int wt_entry_header(WT_ITEM *item, EntryHeader *eh)
+{
+	unsigned char *ptr = (unsigned char *)item->data;
+
+    /* Some overlays can create empty entries
+     * so don't check for zeros here.
+     */
+	eh->nattrs = entry_getlen(&ptr);
+    eh->nvals = entry_getlen(&ptr);
+    eh->data = (char *)ptr;
+	return LDAP_SUCCESS;
+}
+
+Entry *
+wt_tool_entry_get( BackendDB *be, ID id )
+{
+	Entry *e = NULL;
+	static EntryHeader eh;
+	int rc, eoff;
+
+	assert( be != NULL );
+	assert( slapMode & SLAP_TOOL_MODE );
+
+	reader->set_key(reader, id);
+	rc = reader->search(reader);
+	if ( rc ) {
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_tool_entry_get: search failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		goto done;
+	}
+	rc = reader->get_value(reader, &item);
+	if( rc ){
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_tool_entry_get: get_value failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		goto done;
+	}
+
+	rc = wt_entry_header( &item,  &eh );
+	assert( rc == 0 );
+	eoff = eh.data - (char *)item.data;
+
+	eh.bv.bv_len = eh.nvals * sizeof( struct berval ) + item.size;
+	eh.bv.bv_val = ch_realloc( eh.bv.bv_val, eh.bv.bv_len );
+    memset(eh.bv.bv_val, 0xff, eh.bv.bv_len);
+	eh.data = eh.bv.bv_val + eh.nvals * sizeof( struct berval );
+    memcpy(eh.data, item.data, item.size);
+    eh.data += eoff;
+
+	rc = entry_decode( &eh, &e );
+	assert( rc == 0 );
+
+	if( rc == LDAP_SUCCESS ) {
+		e->e_id = id;
+	}
+
+done:
+	return e;
+}
+
+static int wt_tool_next_id(
+    Operation *op,
+    Entry *e,
+    struct berval *text,
+    int hole )
+{
+	struct berval dn = e->e_name;
+	struct berval ndn = e->e_nname;
+	struct berval pdn, npdn;
+	int rc;
+	ID id = 0;
+	ID pid = 0;
+
+    if(ndn.bv_len == 0){
+        e->e_id = 0;
+        return 0;
+    }
+
+	rc = wt_dn2id(op, wc, &ndn, &id);
+	if(rc == 0){
+		e->e_id = id;
+	}else if( rc == WT_NOTFOUND ){
+		if ( !be_issuffix( op->o_bd, &ndn ) ) {
+			ID eid = e->e_id;
+			dnParent( &dn, &pdn );
+			dnParent( &ndn, &npdn );
+			e->e_name = pdn;
+			e->e_nname = npdn;
+			rc = wt_tool_next_id( op, e, text, 1 );
+			e->e_name = dn;
+			e->e_nname = ndn;
+			if ( rc ) {
+				return rc;
+			}
+			/* If parent didn't exist, it was created just now
+			 * and its ID is now in e->e_id. Make sure the current
+			 * entry gets added under the new parent ID.
+			 */
+			if ( eid != e->e_id ) {
+				pid = e->e_id;
+			}
+		}else{
+			pid = id;
+		}
+		wt_next_id( op->o_bd, &e->e_id );
+		rc = wt_dn2id_add(op, wc, pid, e);
+		if( rc ){
+			snprintf( text->bv_val, text->bv_len,
+					  "wt_dn2id_add failed: %s (%d)",
+					  wiredtiger_strerror(rc), rc );
+			Debug( LDAP_DEBUG_ANY,
+				   "=> wt_tool_next_id: %s\n", text->bv_val );
+		}
+
+	}else if ( !hole ) {
+		unsigned i, j;
+		e->e_id = id;
+
+		for ( i=0; i<nholes; i++) {
+			if ( holes[i].id == e->e_id ) {
+				free(holes[i].dn.bv_val);
+				for (j=i;j<nholes;j++) holes[j] = holes[j+1];
+				holes[j].id = 0;
+				nholes--;
+				break;
+			} else if ( holes[i].id > e->e_id ) {
+				break;
+			}
+		}
+	}
+    return rc;
+}
+
+static int
+wt_tool_index_add(
+    Operation *op,
+    wt_ctx *wc,
+    Entry *e )
+{
+	return wt_index_entry_add( op, wc, e );
+}
+
+ID
+wt_tool_entry_put( BackendDB *be, Entry *e, struct berval *text )
+{
+    int rc;
+	Operation op = {0};
+	Opheader ohdr = {0};
+
+	if ( slapMode & SLAP_TOOL_DRYRUN )
+		return 0;
+
+	assert( slapMode & SLAP_TOOL_MODE );
+	assert( text != NULL );
+	assert( text->bv_val != NULL );
+	assert( text->bv_val[0] == '\0' ); /* overconservative? */
+
+    Debug( LDAP_DEBUG_TRACE,
+		   "=> wt_tool_entry_put: ( \"%s\" )\n", e->e_dn );
+
+    rc = wc->session->begin_transaction(wc->session, NULL);
+	if( rc ){
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_dn2id_add: begin_transaction failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		return NOID;
+	}
+
+	op.o_hdr = &ohdr;
+    op.o_bd = be;
+    op.o_tmpmemctx = NULL;
+    op.o_tmpmfuncs = &ch_mfuncs;
+
+    rc = wt_tool_next_id( &op, e, text, 0 );
+	if( rc != 0 ) {
+        snprintf( text->bv_val, text->bv_len,
+				  "wt_tool_next_id failed: %s (%d)",
+				  wiredtiger_strerror(rc), rc );
+        Debug( LDAP_DEBUG_ANY,
+			   "=> wt_tool_entry_put: %s\n", text->bv_val );
+		goto done;
+	}
+
+	rc = wt_id2entry_add( &op, wc, e );
+	if( rc != 0 ) {
+        snprintf( text->bv_val, text->bv_len,
+				  "id2entry_add failed: %s (%d)",
+				  wiredtiger_strerror(rc), rc );
+        Debug( LDAP_DEBUG_ANY,
+			   "=> wt_tool_entry_put: %s\n",
+			   text->bv_val );
+        goto done;
+    }
+
+	rc = wt_tool_index_add( &op, wc, e );
+    if( rc != 0 ) {
+        snprintf( text->bv_val, text->bv_len,
+				  "index_entry_add failed: %s (%d)",
+				  rc == LDAP_OTHER ? "Internal error" :
+				  wiredtiger_strerror(rc), rc );
+        Debug( LDAP_DEBUG_ANY,
+			   "=> wt_tool_entry_put: %s\n", text->bv_val );
+        goto done;
+    }
+
+done:
+	if ( rc == 0 ){
+		rc = wc->session->commit_transaction(wc->session, NULL);
+		if( rc != 0 ) {
+			snprintf( text->bv_val, text->bv_len,
+					  "txn_commit failed: %s (%d)",
+					  wiredtiger_strerror(rc), rc );
+			Debug( LDAP_DEBUG_ANY,
+				   "=> wt_tool_entry_put: %s\n", text->bv_val );
+            e->e_id = NOID;
+		}
+	}else{
+		rc = wc->session->rollback_transaction(wc->session, NULL);
+		snprintf( text->bv_val, text->bv_len,
+				  "txn_aborted! %s (%d)",
+				  rc == LDAP_OTHER ? "Internal error" :
+				  wiredtiger_strerror(rc), rc );
+        Debug( LDAP_DEBUG_ANY,
+			   "=> wt_tool_entry_put: %s\n", text->bv_val );
+        e->e_id = NOID;
+	}
+
+	return e->e_id;
+}
+
+int wt_tool_entry_reindex(
+	BackendDB *be,
+	ID id,
+	AttributeDescription **adv )
+{
+	struct wt_info *wi = (struct wt_info *) be->be_private;
+	int rc;
+	Entry *e;
+	Operation op = {0};
+	Opheader ohdr = {0};
+
+	Debug( LDAP_DEBUG_ARGS,
+		   "=> wt_tool_entry_reindex( %ld )\n", (long) id );
+	assert( tool_base == NULL );
+	assert( tool_filter == NULL );
+
+	/* No indexes configured, nothing to do. Could return an
+     * error here to shortcut things.
+     */
+	if (!wi->wi_attrs) {
+		return 0;
+	}
+
+	/* Check for explicit list of attrs to index */
+	if ( adv ) {
+		int i, j, n;
+
+		if ( wi->wi_attrs[0]->ai_desc != adv[0] ) {
+			/* count */
+			for ( n = 0; adv[n]; n++ ) ;
+
+			/* insertion sort */
+			for ( i = 0; i < n; i++ ) {
+				AttributeDescription *ad = adv[i];
+				for ( j = i-1; j>=0; j--) {
+					if ( SLAP_PTRCMP( adv[j], ad ) <= 0 ) break;
+					adv[j+1] = adv[j];
+				}
+				adv[j+1] = ad;
+			}
+		}
+
+		for ( i = 0; adv[i]; i++ ) {
+			if ( wi->wi_attrs[i]->ai_desc != adv[i] ) {
+				for ( j = i+1; j < wi->wi_nattrs; j++ ) {
+					if ( wi->wi_attrs[j]->ai_desc == adv[i] ) {
+						AttrInfo *ai = wi->wi_attrs[i];
+						wi->wi_attrs[i] = wi->wi_attrs[j];
+						wi->wi_attrs[j] = ai;
+						break;
+					}
+				}
+				if ( j == wi->wi_nattrs ) {
+					Debug( LDAP_DEBUG_ANY,
+						   "wt_tool_entry_reindex: no index configured for %s\n",
+						   adv[i]->ad_cname.bv_val );
+					return -1;
+				}
+			}
+		}
+		wi->wi_nattrs = i;
+	}
+
+	e = wt_tool_entry_get( be, id );
+
+	if( e == NULL ) {
+		Debug( LDAP_DEBUG_ANY, "=> wt_tool_entry_reindex"
+			   ": could not locate id=%ld\n",
+			   (long) id );
+		return -1;
+	}
+
+	op.o_hdr = &ohdr;
+	op.o_bd = be;
+	op.o_tmpmemctx = NULL;
+	op.o_tmpmfuncs = &ch_mfuncs;
+
+	rc = wc->session->begin_transaction(wc->session, NULL);
+	if( rc ){
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_tool_entry_reindex: begin_transaction failed %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		goto done;
+	}
+	Debug( LDAP_DEBUG_TRACE,
+		   "=> wt_tool_entry_reindex( %ld, \"%s\" )\n",
+		   (long) id, e->e_dn );
+
+	rc = wt_tool_index_add( &op, wc, e );
+
+done:
+	if ( rc == 0 ){
+		rc = wc->session->commit_transaction(wc->session, NULL);
+		if( rc ) {
+			Debug( LDAP_DEBUG_ANY,
+				   "=> wt_tool_entry_reindex: commit_transaction failed %s (%d)\n",
+				   wiredtiger_strerror(rc), rc );
+		}
+	}else{
+		rc = wc->session->rollback_transaction(wc->session, NULL);
+		Debug( LDAP_DEBUG_ANY,
+			   "=> wt_tool_entry_reindex: rollback transaction %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+	}
+
+	wt_entry_release( &op, e, 0 );
+
+	return rc;
+}
+
+ID wt_tool_dn2id_get(
+	Backend *be,
+	struct berval *dn
+)
+{
+	Operation op = {0};
+	Opheader ohdr = {0};
+	ID id;
+	int rc;
+
+	if ( BER_BVISEMPTY(dn) )
+		return 0;
+
+	op.o_hdr = &ohdr;
+	op.o_bd = be;
+	op.o_tmpmemctx = NULL;
+	op.o_tmpmfuncs = &ch_mfuncs;
+
+	rc = wt_dn2id(&op, wc, dn, &id);
+	switch( rc ){
+	case 0:
+		break;
+	case WT_NOTFOUND:
+		return NOID;
+	default:
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_tool_entry_get: entry get failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		return NOID;
+	}
+	return id;
+}
+
+ID wt_tool_entry_modify(
+	BackendDB *be,
+	Entry *e,
+	struct berval *text )
+{
+	int rc;
+	Operation op = {0};
+	Opheader ohdr = {0};
+
+	assert( be != NULL );
+	assert( slapMode & SLAP_TOOL_MODE );
+
+	assert( text != NULL );
+	assert( text->bv_val != NULL );
+	assert( text->bv_val[0] == '\0' );	/* overconservative? */
+
+	assert ( e->e_id != NOID );
+
+	Debug( LDAP_DEBUG_TRACE,
+		   "=> wt_tool_entry_modify( %ld, \"%s\" )\n",
+		   (long) e->e_id, e->e_dn );
+
+    rc = wc->session->begin_transaction(wc->session, NULL);
+	if( rc ){
+		Debug( LDAP_DEBUG_ANY, "=> wt_tool_entry_modify"
+			   ": begin_transaction failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		return NOID;
+	}
+
+	op.o_hdr = &ohdr;
+	op.o_bd = be;
+	op.o_tmpmemctx = NULL;
+	op.o_tmpmfuncs = &ch_mfuncs;
+
+	rc = wt_id2entry_update( &op, wc, e );
+	if( rc != 0 ) {
+        snprintf( text->bv_val, text->bv_len,
+				  "id2entry_update failed: %s (%d)",
+				  wiredtiger_strerror(rc), rc );
+        Debug( LDAP_DEBUG_ANY, "=> wt_tool_entry_modify: %s\n",
+			   text->bv_val );
+        goto done;
+    }
+
+done:
+	if ( rc == 0 ){
+		rc = wc->session->commit_transaction(wc->session, NULL);
+		if( rc != 0 ) {
+			snprintf( text->bv_val, text->bv_len,
+					  "txn_commit failed: %s (%d)",
+					  wiredtiger_strerror(rc), rc );
+			Debug( LDAP_DEBUG_ANY, "=> wt_tool_entry_modify: %s\n",
+				   text->bv_val );
+            e->e_id = NOID;
+		}
+	}else{
+		rc = wc->session->rollback_transaction(wc->session, NULL);
+		snprintf( text->bv_val, text->bv_len,
+				  "txn_aborted! %s (%d)",
+				  rc == LDAP_OTHER ? "Internal error" :
+				  wiredtiger_strerror(rc), rc );
+		Debug( LDAP_DEBUG_ANY, "=> wt_tool_entry_modify: %s\n",
+			   text->bv_val );
+		e->e_id = NOID;
+	}
+
+	return e->e_id;
+}
+
+int wt_tool_entry_delete(
+	BackendDB *be,
+	struct berval *ndn,
+	struct berval *text )
+{
+    struct wt_info *wi = (struct wt_info *) be->be_private;
+    int rc;
+	Operation op = {0};
+	Opheader ohdr = {0};
+	Entry *e = NULL;
+
+	assert( be != NULL );
+	assert( slapMode & SLAP_TOOL_MODE );
+
+	assert( text != NULL );
+	assert( text->bv_val != NULL );
+	assert( text->bv_val[0] == '\0' );	/* overconservative? */
+
+	assert ( ndn != NULL );
+	assert ( ndn->bv_val != NULL );
+
+	Debug( LDAP_DEBUG_TRACE,
+		   "=> wt_tool_entry_delete( %s )\n",
+		   ndn->bv_val );
+
+	op.o_hdr = &ohdr;
+	op.o_bd = be;
+	op.o_tmpmemctx = NULL;
+	op.o_tmpmfuncs = &ch_mfuncs;
+
+	/* get entry */
+	rc = wt_dn2entry(op.o_bd, wc, ndn, &e);
+	switch( rc ) {
+	case 0:
+		break;
+	case WT_NOTFOUND:
+		Debug( LDAP_DEBUG_ARGS,
+			   "<== wt_tool_entry_delete: no such object %s\n",
+			   ndn->bv_val);
+		goto done;
+	default:
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_tool_entry_delete: error at wt_dn2entry() rc=%d\n",
+			   rc );
+		goto done;
+	}
+
+	rc = wt_dn2id_has_children( &op, wc, e->e_id );
+	if( rc != WT_NOTFOUND ) {
+		/* subordinate objects must be deleted first */
+		rc = -1;
+		goto done;
+	}
+
+	rc = wc->session->begin_transaction(wc->session, NULL);
+	if( rc ){
+		Debug( LDAP_DEBUG_ANY,
+			   "wt_tool_entry_delete: begin_transaction failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		goto done;
+	}
+
+	/* delete from dn2id */
+	rc = wt_dn2id_delete( &op, wc, &e->e_nname);
+	if ( rc ) {
+		Debug( LDAP_DEBUG_TRACE,
+			  "<== wt_tool_entry_delete: dn2id failed: %s (%d)\n",
+			  wiredtiger_strerror(rc), rc );
+		wc->session->rollback_transaction(wc->session, NULL);
+		goto done;
+	}
+
+	/* delete indices for old attributes */
+	rc = wt_index_entry_del( &op, wc, e );
+	if ( rc ) {
+		Debug( LDAP_DEBUG_TRACE,
+			  "<== wt_tool_entry_delete: index delete failed: %s (%d)\n",
+			  wiredtiger_strerror(rc), rc );
+		wc->session->rollback_transaction(wc->session, NULL);
+		goto done;
+	}
+
+	/* delete from id2entry */
+	rc = wt_id2entry_delete( &op, wc, e );
+	if ( rc ) {
+		Debug( LDAP_DEBUG_TRACE,
+			   "<== wt_tool_entry_delete: id2entry failed: %s (%d)\n",
+			   wiredtiger_strerror(rc), rc );
+		wc->session->rollback_transaction(wc->session, NULL);
+		goto done;
+	}
+
+	rc = wc->session->commit_transaction(wc->session, NULL);
+	if( rc != 0 ) {
+		snprintf( text->bv_val, text->bv_len,
+				  "txn_commit failed: %s (%d)",
+				  wiredtiger_strerror(rc), rc );
+		Debug( LDAP_DEBUG_ANY,
+			   "=> wt_tool_entry_delete: %s\n",
+			   text->bv_val );
+		goto done;
+	}
+
+done:
+	/* free entry */
+	if( e != NULL ) {
+		wt_entry_return( e );
+	}
+	return rc;
+}
+
+
+/*
+ * Local variables:
+ * indent-tabs-mode: t
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */