X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fslap.h;h=939198ed28ae3950c5a4f83eb65f7998b3a5f91a;hb=fbc6a7e8ac780fd421e057c34caa9d4ecb166807;hp=152f971462fd3774a753250608d3f99c7e9b45b8;hpb=e1bf8cc437cd21381006ea176f82dc92a1728eec;p=openldap

diff --git a/servers/slapd/slap.h b/servers/slapd/slap.h
index 152f971462..939198ed28 100644
--- a/servers/slapd/slap.h
+++ b/servers/slapd/slap.h
@@ -35,7 +35,10 @@
 #include "ldap_pvt_thread.h"
 #include "ldap_queue.h"
 
+#ifdef LDAP_DEVEL
 #define SLAP_EXTENDED_SCHEMA 1
+#define LDAP_CACHING
+#endif
 
 LDAP_BEGIN_DECL
 /*
@@ -72,11 +75,14 @@ LDAP_BEGIN_DECL
 
 #define MAXREMATCHES (100)
 
-#define SLAP_MAX_WORKER_THREADS		(32)
+#define SLAP_MAX_WORKER_THREADS		(16)
 
 #define SLAP_SB_MAX_INCOMING_DEFAULT ((1<<18) - 1)
 #define SLAP_SB_MAX_INCOMING_AUTH ((1<<24) - 1)
 
+#define SLAP_CONN_MAX_PENDING_DEFAULT	100
+#define SLAP_CONN_MAX_PENDING_AUTH	1000
+
 #define SLAP_TEXT_BUFLEN (256)
 
 /* psuedo error code indicating abandoned operation */
@@ -165,7 +171,6 @@ typedef struct slap_ssf_set {
 	slap_ssf_t sss_simple_bind;
 } slap_ssf_set_t;
 
-
 /* Flags for telling slap_sasl_getdn() what type of identity is being passed */
 #define SLAP_GETDN_AUTHCID 2
 #define SLAP_GETDN_AUTHZID 4
@@ -314,7 +319,6 @@ typedef struct slap_syntax {
 #define SLAP_SYNTAX_HIDE	0x8000U /* hide (do not publish) */
 
 	slap_syntax_validate_func	*ssyn_validate;
-	slap_syntax_transform_func	*ssyn_normalize;
 	slap_syntax_transform_func	*ssyn_pretty;
 
 #ifdef SLAPD_BINARY_CONVERSION
@@ -336,7 +340,7 @@ typedef struct slap_syntax_defs_rec {
 	char *sd_desc;
 	int sd_flags;
 	slap_syntax_validate_func *sd_validate;
-	slap_syntax_transform_func *sd_normalize;
+	slap_syntax_transform_func *sd_normalizeXXX; /* to be deleted */
 	slap_syntax_transform_func *sd_pretty;
 #ifdef SLAPD_BINARY_CONVERSION
 	slap_syntax_transform_func *sd_ber2str;
@@ -408,46 +412,64 @@ typedef struct slap_matching_rule {
 
 #define SLAP_MR_HIDE			0x8000U
 
-#define SLAP_MR_TYPE_MASK		0x0F00U
-#define SLAP_MR_SUBTYPE_MASK	0x00F0U
-#define SLAP_MR_USAGE			0x000FU
+#define SLAP_MR_TYPE_MASK		0xF000U
+#define SLAP_MR_SUBTYPE_MASK	0x0F00U
+#define SLAP_MR_USAGE			0x00FFU
 
 #define SLAP_MR_NONE			0x0000U
-#define SLAP_MR_EQUALITY		0x0100U
-#define SLAP_MR_ORDERING		0x0200U
-#define SLAP_MR_SUBSTR			0x0400U
-#define SLAP_MR_EXT				0x0800U /* implicitly extensible */
+#define SLAP_MR_EQUALITY		0x1000U
+#define SLAP_MR_ORDERING		0x2000U
+#define SLAP_MR_SUBSTR			0x4000U
+#define SLAP_MR_EXT				0x8000U /* implicitly extensible */
+
+#define SLAP_MR_EQUALITY_APPROX	( SLAP_MR_EQUALITY | 0x0100U )
 
-#define SLAP_MR_EQUALITY_APPROX	( SLAP_MR_EQUALITY | 0x0010U )
-#define SLAP_MR_DN_FOLD			0x0008U
+#define SLAP_MR_SUBSTR_INITIAL	( SLAP_MR_SUBSTR | 0x0100U )
+#define SLAP_MR_SUBSTR_ANY		( SLAP_MR_SUBSTR | 0x0200U )
+#define SLAP_MR_SUBSTR_FINAL	( SLAP_MR_SUBSTR | 0x0400U )
 
-#define SLAP_MR_SUBSTR_INITIAL	( SLAP_MR_SUBSTR | 0x0010U )
-#define SLAP_MR_SUBSTR_ANY		( SLAP_MR_SUBSTR | 0x0020U )
-#define SLAP_MR_SUBSTR_FINAL	( SLAP_MR_SUBSTR | 0x0040U )
 
 /*
- * normally the provided value is expected to conform to
- * assertion syntax specified in the matching rule, however
- * at times (such as during individual value modification),
- * the provided value is expected to conform to the
- * attribute's value syntax.
+ * The asserted value, depending on the particular usage,
+ * is expected to conform to either the assertion syntax
+ * or the attribute syntax.   In some cases, the syntax of
+ * the value is known.  If so, these flags indicate which
+ * syntax the value is expected to conform to.  If not,
+ * neither of these flags is set (until the syntax of the
+ * provided value is determined).  If the value is of the
+ * attribute syntax, the flag is changed once a value of
+ * the assertion syntax is derived from the provided value.
  */
-#define SLAP_MR_ASSERTION_SYNTAX_MATCH			0x0000U
-#define SLAP_MR_VALUE_SYNTAX_MATCH				0x0001U
-#define SLAP_MR_VALUE_SYNTAX_CONVERTED_MATCH	0x0003U
-#define SLAP_MR_VALUE_NORMALIZED_MATCH	0x0004U
+#define SLAP_MR_VALUE_OF_ASSERTION_SYNTAX	0x0001U
+#define SLAP_MR_VALUE_OF_ATTRIBUTE_SYNTAX	0x0002U
 
-#define SLAP_IS_MR_ASSERTION_SYNTAX_MATCH( usage ) \
-	(!((usage) & SLAP_MR_VALUE_SYNTAX_MATCH))
-#define SLAP_IS_MR_VALUE_SYNTAX_MATCH( usage ) \
-	((usage) & SLAP_MR_VALUE_SYNTAX_MATCH)
+#define SLAP_MR_IS_VALUE_OF_ATTRIBUTE_SYNTAX( usage ) \
+	((usage) & SLAP_MR_VALUE_OF_ATTRIBUTE_SYNTAX )
+#define SLAP_MR_IS_VALUE_OF_ASSERTION_SYNTAX( usage ) \
+	((usage) & SLAP_MR_VALUE_OF_ASSERTION_SYNTAX )
+
+/* either or both the asserted value or attribute value
+ * may be provided in normalized form
+ */
+#define SLAP_MR_ASSERTED_VALUE_NORMALIZED_MATCH		0x0010U
+#define SLAP_MR_ATTRIBUTE_VALUE_NORMALIZED_MATCH	0x0020U
 
-#define SLAP_IS_MR_VALUE_SYNTAX_CONVERTED_MATCH( usage ) \
-	(((usage) & SLAP_MR_VALUE_SYNTAX_CONVERTED_MATCH) \
-		== SLAP_MR_VALUE_SYNTAX_CONVERTED_MATCH)
-#define SLAP_IS_MR_VALUE_SYNTAX_NONCONVERTED_MATCH( usage ) \
-	(((usage) & SLAP_MR_VALUE_SYNTAX_CONVERTED_MATCH) \
-		== SLAP_MR_VALUE_SYNTAX_MATCH)
+#define SLAP_IS_MR_ASSERTION_SYNTAX_MATCH( usage ) \
+	(!((usage) & SLAP_MR_ATTRIBUTE_SYNTAX_MATCH))
+#define SLAP_IS_MR_ATTRIBUTE_SYNTAX_MATCH( usage ) \
+	((usage) & SLAP_MR_ATTRIBUTE_SYNTAX_MATCH)
+
+#define SLAP_IS_MR_ATTRIBUTE_SYNTAX_CONVERTED_MATCH( usage ) \
+	(((usage) & SLAP_MR_ATTRIBUTE_SYNTAX_CONVERTED_MATCH) \
+		== SLAP_MR_ATTRIBUTE_SYNTAX_CONVERTED_MATCH)
+#define SLAP_IS_MR_ATTRIBUTE_SYNTAX_NONCONVERTED_MATCH( usage ) \
+	(((usage) & SLAP_MR_ATTRIBUTE_SYNTAX_CONVERTED_MATCH) \
+		== SLAP_MR_ATTRIBUTE_SYNTAX_MATCH)
+
+#define SLAP_IS_MR_ASSERTED_VALUE_NORMALIZED_MATCH( usage ) \
+	((usage) & SLAP_MR_ASSERTED_VALUE_NORMALIZED_MATCH )
+#define SLAP_IS_MR_ATTRIBUTE_VALUE_NORMALIZED_MATCH( usage ) \
+	((usage) & SLAP_MR_ATTRIBUTE_VALUE_NORMALIZED_MATCH )
 
 	Syntax					*smr_syntax;
 	slap_mr_convert_func	*smr_convert;
@@ -501,6 +523,7 @@ typedef struct slap_mrule_defs_rec {
 	slap_mr_indexer_func *		mrd_indexer;
 	slap_mr_filter_func *		mrd_filter;
 
+	/* For equality rule, this may refer to an appropriate approximate rule */
 	char *						mrd_associated;
 } slap_mrule_defs_rec;
 
@@ -678,8 +701,14 @@ struct slap_internal_schema {
 	AttributeDescription *si_ad_collectiveExclusions;
 	AttributeDescription *si_ad_entryUUID;
 	AttributeDescription *si_ad_entryCSN;
+	AttributeDescription *si_ad_namingCSN;
 	AttributeDescription *si_ad_superiorUUID;
 
+#ifdef LDAP_CACHING
+	/* LDAP cache specific operational attribute */
+	AttributeDescription *si_ad_queryid;
+#endif /* LDAP_CACHING */
+
 	/* root DSE attribute descriptions */
 	AttributeDescription *si_ad_altServer;
 	AttributeDescription *si_ad_namingContexts;
@@ -740,12 +769,17 @@ struct slap_internal_schema {
 
 	/* Matching Rules */
 	MatchingRule	*si_mr_distinguishedNameMatch;
+	MatchingRule    *si_mr_caseExactMatch;
+	MatchingRule    *si_mr_caseExactSubstringsMatch;
+	MatchingRule    *si_mr_caseExactIA5Match;
 	MatchingRule	*si_mr_integerMatch;
+	MatchingRule    *si_mr_integerFirstComponentMatch;
 
 	/* Syntaxes */
-	Syntax		*si_syn_octetString;
+	Syntax		*si_syn_directoryString;
 	Syntax		*si_syn_distinguishedName;
 	Syntax		*si_syn_integer;
+	Syntax		*si_syn_octetString;
 };
 
 typedef struct slap_attr_assertion {
@@ -881,8 +915,9 @@ typedef struct slap_valuesreturnfilter {
  */
 typedef struct slap_attr {
 	AttributeDescription *a_desc;
-	BerVarray	a_vals;
-	struct slap_attr	*a_next;
+	BerVarray	a_vals;		/* preserved values */
+	BerVarray	a_nvals;	/* normalized values */
+	struct slap_attr *a_next;
 	unsigned a_flags;
 #define SLAP_ATTR_IXADD		0x1U
 #define SLAP_ATTR_IXDEL		0x2U
@@ -930,7 +965,9 @@ typedef struct slap_mod {
 	int sm_op;
 	AttributeDescription *sm_desc;
 	struct berval sm_type;
-	BerVarray sm_bvalues;
+	BerVarray sm_values;
+#define sm_bvalues sm_values
+	BerVarray sm_nvalues;
 } Modification;
 
 typedef struct slap_mod_list {
@@ -938,7 +975,9 @@ typedef struct slap_mod_list {
 #define sml_op		sml_mod.sm_op
 #define sml_desc	sml_mod.sm_desc
 #define	sml_type	sml_mod.sm_type
-#define sml_bvalues	sml_mod.sm_bvalues
+#define sml_bvalues	sml_mod.sm_values
+#define sml_values	sml_mod.sm_values
+#define sml_nvalues	sml_mod.sm_nvalues
 	struct slap_mod_list *sml_next;
 } Modifications;
 
@@ -948,7 +987,7 @@ typedef struct slap_ldap_modlist {
 #define ml_op		ml_mod.mod_op
 #define ml_type		ml_mod.mod_type
 #define ml_values	ml_mod.mod_values
-#define ml_bvalues	ml_mod.mod_bvalues
+#define ml_bvalues	ml_mod.mod_values
 } LDAPModList;
 
 /*
@@ -1132,15 +1171,6 @@ typedef struct slap_acl_state {
 #define ACL_STATE_INIT { ACL_STATE_NOT_RECORDED, NULL, NULL, 0UL, \
 	{ { 0, 0 } }, 0, NULL, 0, 0, NULL }
 
-/*
- * replog moddn param structure
- */
-struct slap_replog_moddn {
-	struct berval *newrdn;
-	int	deloldrdn;
-	struct berval *newsup;
-};
-
 /*
  * Backend-info
  * represents a backend 
@@ -1225,9 +1255,12 @@ struct slap_backend_db {
 #define		be_modify	bd_info->bi_op_modify
 #define		be_modrdn	bd_info->bi_op_modrdn
 #define		be_search	bd_info->bi_op_search
+#define		be_abandon	bd_info->bi_op_abandon
+#define		be_cancel	bd_info->bi_op_cancel
 
 #define		be_extended	bd_info->bi_extended
 
+#define		be_fetch	bd_info->bi_entry_get_rw
 #define		be_release	bd_info->bi_entry_release_rw
 #define		be_chk_referrals	bd_info->bi_chk_referrals
 #define		be_group	bd_info->bi_acl_group
@@ -1268,6 +1301,10 @@ struct slap_backend_db {
 #define SLAP_BFLAG_DYNAMIC		0x2000U
 	slap_mask_t	be_flags;
 #define SLAP_LASTMOD(be)	(!((be)->be_flags & SLAP_BFLAG_NOLASTMOD))
+#define	SLAP_GLUE_INSTANCE(be)	((be)->be_flags & SLAP_BFLAG_GLUE_INSTANCE)
+#define	SLAP_GLUE_SUBORDINATE(be) \
+	((be)->be_flags & SLAP_BFLAG_GLUE_SUBORDINATE)
+#define	SLAP_GLUE_LINKED(be)	((be)->be_flags & SLAP_BFLAG_GLUE_LINKED)
 #define SLAP_ALIASES(be)	((be)->be_flags & SLAP_BFLAG_ALIASES)
 #define SLAP_REFERRALS(be)	((be)->be_flags & SLAP_BFLAG_REFERRALS)
 #define SLAP_SUBENTRIES(be)	((be)->be_flags & SLAP_BFLAG_SUBENTRIES)
@@ -1323,7 +1360,6 @@ struct slap_backend_db {
 	/* these should be renamed from be_ to bd_ */
 	BerVarray	be_suffix;	/* the DN suffixes of data in this backend */
 	BerVarray	be_nsuffix;	/* the normalized DN suffixes in this backend */
-	BerVarray	be_suffixAlias; /* pairs of DN suffix aliases and deref values */
 	struct berval be_schemadn;	/* per-backend subschema subentry DN */
 	struct berval be_schemandn;	/* normalized subschema DN */
 	struct berval be_rootdn;	/* the magic "root" name (DN) for this db */
@@ -1366,85 +1402,119 @@ typedef int (BI_db_open) LDAP_P((Backend *bd));
 typedef int (BI_db_close) LDAP_P((Backend *bd));
 typedef int (BI_db_destroy) LDAP_P((Backend *bd));
 
-typedef int (BI_op_bind)  LDAP_P(( BackendDB *bd,
-		struct slap_conn *c, struct slap_op *o,
-		struct berval *dn, struct berval *ndn, int method,
-		struct berval *cred, struct berval *edn ));
-typedef int (BI_op_unbind) LDAP_P((BackendDB *bd,
-		struct slap_conn *c, struct slap_op *o ));
-typedef int (BI_op_search) LDAP_P((BackendDB *bd,
-		struct slap_conn *c, struct slap_op *o,
-		struct berval *base, struct berval *nbase,
-		int scope, int deref,
-		int slimit, int tlimit,
-		Filter *f, struct berval *filterstr,
-		AttributeName *attrs, int attrsonly));
-typedef int (BI_op_compare)LDAP_P((BackendDB *bd,
-		struct slap_conn *c, struct slap_op *o,
-		struct berval *dn, struct berval *ndn,
-		AttributeAssertion *ava));
-typedef int (BI_op_modify) LDAP_P((BackendDB *bd,
-		struct slap_conn *c, struct slap_op *o,
-		struct berval *dn, struct berval *ndn,
-		Modifications *m));
-typedef int (BI_op_modrdn) LDAP_P((BackendDB *bd,
-		struct slap_conn *c, struct slap_op *o,
-		struct berval *dn, struct berval *ndn,
-		struct berval *newrdn, struct berval *nnewrdn,
-		int deleteoldrdn,
-		struct berval *newSup, struct berval *nnewSup ));
-typedef int (BI_op_add)    LDAP_P((BackendDB *bd,
-		struct slap_conn *c, struct slap_op *o,
-		Entry *e));
-typedef int (BI_op_delete) LDAP_P((BackendDB *bd,
-		struct slap_conn *c, struct slap_op *o,
-		struct berval *dn, struct berval *ndn));
-typedef int (BI_op_abandon) LDAP_P((BackendDB *bd,
-		struct slap_conn *c, struct slap_op *o,
-		ber_int_t msgid));
-
-typedef int (BI_op_extended) LDAP_P((
-	BackendDB		*be,
-	struct slap_conn	*conn,
-	struct slap_op		*op,
-	const char		*reqoid,
-	struct berval * reqdata,
-	char		**rspoid,
-	struct berval ** rspdata,
-	LDAPControl *** rspctrls,
-	const char **	text,
-	BerVarray *refs ));
-
-typedef int (BI_entry_release_rw) LDAP_P((BackendDB *bd,
-		struct slap_conn *c, struct slap_op *o,
-		Entry *e, int rw));
-
-typedef int (BI_chk_referrals) LDAP_P((BackendDB *bd,
-		struct slap_conn *c, struct slap_op *o,
-		struct berval *dn, struct berval *ndn,
-		const char **text ));
-
-typedef int (BI_acl_group)  LDAP_P((Backend *bd,
-		struct slap_conn *c, struct slap_op *o,
-		Entry *e,
-		struct berval *bdn,
-		struct berval *edn,
-		ObjectClass *group_oc,
-		AttributeDescription *group_at ));
-
-typedef int (BI_acl_attribute)  LDAP_P((Backend *bd,
-		struct slap_conn *c, struct slap_op *o,
-		Entry *e, struct berval *edn,
-		AttributeDescription *entry_at,
-		BerVarray *vals ));
-
-typedef int (BI_operational)  LDAP_P((Backend *bd,
-		struct slap_conn *c, struct slap_op *o,
-		Entry *e, AttributeName *attrs, int opattrs, Attribute **a ));
-
-typedef int (BI_has_subordinates) LDAP_P((Backend *bd,
-		struct slap_conn *c, struct slap_op *o,
-	        Entry *e, int *has_subordinates ));
+typedef struct req_bind_s {
+	int rb_method;
+	struct berval rb_cred;
+	struct berval rb_edn;
+	slap_ssf_t rb_ssf;
+} req_bind_s;
+
+typedef struct req_search_s {
+	int rs_scope;
+	int rs_deref;
+	int rs_slimit;
+	int rs_tlimit;
+	int rs_attrsonly;
+	AttributeName *rs_attrs;
+	Filter *rs_filter;
+	struct berval rs_filterstr;
+} req_search_s;
+
+typedef struct req_compare_s {
+	AttributeAssertion *rs_ava;
+} req_compare_s;
+
+typedef struct req_modify_s {
+	Modifications *rs_modlist;
+} req_modify_s;
+
+typedef struct req_modrdn_s {
+	struct berval rs_newrdn;
+	struct berval rs_nnewrdn;
+	struct berval *rs_newSup;
+	struct berval *rs_nnewSup;
+	int rs_deleteoldrdn;
+} req_modrdn_s;
+
+typedef struct req_add_s {
+	Entry *rs_e;
+} req_add_s;
+
+typedef struct req_abandon_s {
+	ber_int_t rs_msgid;
+} req_abandon_s;
+
+typedef struct req_extended_s {
+	struct berval rs_reqoid;
+	struct berval *rs_reqdata;
+} req_extended_s;
+
+typedef enum slap_reply_e {
+	REP_RESULT,
+	REP_SASL,
+	REP_EXTENDED,
+	REP_SEARCH,
+	REP_SEARCHREF
+} slap_reply_t;
+
+typedef struct rep_sasl_s {
+	struct berval *r_sasldata;
+} rep_sasl_s;
+
+typedef struct rep_extended_s {
+	const char *r_rspoid;
+	struct berval *r_rspdata;
+} rep_extended_s;
+
+typedef struct rep_search_s {
+	Entry *r_entry;
+	AttributeName *r_attrs;
+	int r_nentries;
+	BerVarray r_v2ref;
+} rep_search_s;
+
+typedef struct slap_rep {
+	slap_reply_t sr_type;
+	ber_tag_t sr_tag;
+	ber_int_t sr_msgid;
+	ber_int_t sr_err;
+	const char *sr_matched;
+	const char *sr_text;
+	BerVarray sr_ref;
+	LDAPControl **sr_ctrls;
+	union sr_u {
+		rep_sasl_s sru_sasl;
+		rep_extended_s sru_extended;
+		rep_search_s sru_search;
+	} sr_un;
+} SlapReply;
+
+/* short hands for response members */
+#define	sr_attrs sr_un.sru_search.r_attrs
+#define	sr_entry sr_un.sru_search.r_entry
+#define	sr_v2ref sr_un.sru_search.r_v2ref
+#define	sr_nentries sr_un.sru_search.r_nentries
+#define	sr_rspoid sr_un.sru_extended.r_rspoid
+#define	sr_rspdata sr_un.sru_extended.r_rspdata
+#define	sr_sasldata sr_un.sru_sasl.r_sasldata
+
+typedef int (BI_op_bind) LDAP_P(( struct slap_op *op, struct slap_rep *rs ));
+typedef int (BI_op_unbind) LDAP_P(( struct slap_op *op, struct slap_rep *rs ));
+typedef int (BI_op_search) LDAP_P(( struct slap_op *op, struct slap_rep *rs ));
+typedef int (BI_op_compare) LDAP_P(( struct slap_op *op, struct slap_rep *rs ));
+typedef int (BI_op_modify) LDAP_P(( struct slap_op *op, struct slap_rep *rs ));
+typedef int (BI_op_modrdn) LDAP_P(( struct slap_op *op, struct slap_rep *rs ));
+typedef int (BI_op_add) LDAP_P(( struct slap_op *op, struct slap_rep *rs ));
+typedef int (BI_op_delete) LDAP_P(( struct slap_op *op, struct slap_rep *rs ));
+typedef int (BI_op_abandon) LDAP_P(( struct slap_op *op, struct slap_rep *rs ));
+typedef int (BI_op_cancel) LDAP_P(( struct slap_op *op, struct slap_rep *rs ));
+typedef int (BI_op_extended) LDAP_P(( struct slap_op *op, struct slap_rep *rs ));
+typedef int (BI_entry_release_rw) LDAP_P(( struct slap_op *op, Entry *e, int rw ));
+typedef int (BI_entry_get_rw) LDAP_P(( struct slap_op *op, struct berval *ndn,
+	ObjectClass *oc, AttributeDescription *at, int rw, Entry **e ));
+typedef int (BI_chk_referrals) LDAP_P(( struct slap_op *op, struct slap_rep *rs ));
+typedef int (BI_operational) LDAP_P(( struct slap_op *op, struct slap_rep *rs, int opattrs, Attribute **ap ));
+typedef int (BI_has_subordinates) LDAP_P(( struct slap_op *op, Entry *e, int *hasSubs ));
 
 typedef int (BI_connection_init) LDAP_P((BackendDB *bd,
 		struct slap_conn *c));
@@ -1527,17 +1597,16 @@ struct slap_backend_info {
 	BI_op_add	*bi_op_add;
 	BI_op_delete	*bi_op_delete;
 	BI_op_abandon	*bi_op_abandon;
+	BI_op_cancel	*bi_op_cancel;
 
 	/* Extended Operations Helper */
 	BI_op_extended	*bi_extended;
 
 	/* Auxilary Functions */
+	BI_entry_get_rw		*bi_entry_get_rw;
 	BI_entry_release_rw	*bi_entry_release_rw;
 	BI_chk_referrals	*bi_chk_referrals;
 
-	BI_acl_group	*bi_acl_group;
-	BI_acl_attribute	*bi_acl_attribute;
-
 	BI_operational	*bi_operational;
 	BI_has_subordinates	*bi_has_subordinates;
 
@@ -1581,26 +1650,10 @@ struct slap_backend_info {
 #define o_tls_ssf		o_authz.sai_tls_ssf
 #define o_sasl_ssf		o_authz.sai_sasl_ssf
 
-typedef void (slap_response)( struct slap_conn *, struct slap_op *,
-	ber_tag_t, ber_int_t, ber_int_t, const char *, const char *,
-	BerVarray, const char *, struct berval *,
-	struct berval *, LDAPControl ** );
-
-typedef void (slap_sresult)( struct slap_conn *, struct slap_op *,
-	ber_int_t, const char *, const char *, BerVarray,
-	LDAPControl **, int nentries);
-
-typedef int (slap_sendentry)( BackendDB *, struct slap_conn *,
-	struct slap_op *, Entry *, AttributeName *, int, LDAPControl **);
-
-typedef int (slap_sendreference)( BackendDB *, struct slap_conn *,
-	struct slap_op *, Entry *, BerVarray, LDAPControl **, BerVarray * );
+typedef int (slap_response)( struct slap_op *, struct slap_rep * );
 
 typedef struct slap_callback {
 	slap_response *sc_response;
-	slap_sresult *sc_sresult;
-	slap_sendentry *sc_sendentry;
-	slap_sendreference *sc_sendreference;
 	void *sc_private;
 } slap_callback;
 
@@ -1615,36 +1668,18 @@ typedef struct slap_paged_state {
 } PagedResultsState;
 
 
-#ifdef LDAP_CLIENT_UPDATE
-#define LCUP_PSEARCH_BY_ADD 0x01
-#define LCUP_PSEARCH_BY_DELETE 0x02
-#define LCUP_PSEARCH_BY_PREMODIFY 0x03
-#define LCUP_PSEARCH_BY_MODIFY 0x04
-#define LCUP_PSEARCH_BY_SCOPEOUT 0x05
-
-struct lcup_search_spec {
-	struct slap_op  *op;
-	struct berval   *base;
-	struct berval   *nbase;
-	int             scope;
-	int             deref;
-	int             slimit;
-	int             tlimit;
-	Filter          *filter;
-	struct berval   *filterstr;
-	AttributeName   *attrs;
-	int             attrsonly;
-	struct lcup_entry *elist;
-	ldap_pvt_thread_mutex_t elist_mutex;
-	int             entry_count;
-	LDAP_LIST_ENTRY(lcup_search_spec) link;
-};
+#if defined(LDAP_CLIENT_UPDATE) || defined(LDAP_SYNC)
+#define LDAP_PSEARCH_BY_ADD		0x01
+#define LDAP_PSEARCH_BY_DELETE		0x02
+#define LDAP_PSEARCH_BY_PREMODIFY	0x03
+#define LDAP_PSEARCH_BY_MODIFY		0x04
+#define LDAP_PSEARCH_BY_SCOPEOUT	0x05
 
 struct psid_entry {
-	struct lcup_search_spec* ps;
-	LDAP_LIST_ENTRY(psid_entry) link;
+	struct slap_op *ps_op;
+	LDAP_LIST_ENTRY(psid_entry) ps_link;
 };
-#endif /* LDAP_CLIENT_UPDATE */
+#endif
 
 
 /*
@@ -1654,36 +1689,118 @@ typedef struct slap_op {
 	unsigned long o_opid;	/* id of this operation */
 	unsigned long o_connid; /* id of conn initiating this op */
 	struct slap_conn *o_conn;	/* connection spawning this op */
+	BackendDB	*o_bd;	/* backend DB processing this op */
 
 	ber_int_t	o_msgid;	/* msgid of the request */
 	ber_int_t	o_protocol;	/* version of the LDAP protocol used by client */
 	ber_tag_t	o_tag;		/* tag of the request */
 	time_t		o_time;		/* time op was initiated */
 
-	char *		o_extendedop;	/* extended operation OID */
+	struct berval	o_req_dn;	/* DN of target of request */
+	struct berval	o_req_ndn;
+
+	union o_req_u {
+		req_add_s oq_add;
+		req_bind_s oq_bind;
+		req_compare_s oq_compare;
+		req_modify_s oq_modify;
+		req_modrdn_s oq_modrdn;
+		req_search_s oq_search;
+		req_abandon_s oq_abandon;
+		req_abandon_s oq_cancel;
+		req_extended_s oq_extended;
+	} o_request;
+
+/* short hands for union members */
+#define oq_add o_request.oq_add
+#define oq_bind o_request.oq_bind
+#define oq_compare o_request.oq_compare
+#define oq_modify o_request.oq_modify
+#define oq_modrdn o_request.oq_modrdn
+#define oq_search o_request.oq_search
+#define oq_abandon o_request.oq_abandon
+#define oq_cancel o_request.oq_cancel
+#define oq_extended o_request.oq_extended
+
+/* short hands for inner request members */
+#define orb_method oq_bind.rb_method
+#define orb_cred oq_bind.rb_cred
+#define orb_edn oq_bind.rb_edn
+#define orb_ssf oq_bind.rb_ssf
+
+#define ors_scope oq_search.rs_scope
+#define ors_deref oq_search.rs_deref
+#define ors_slimit oq_search.rs_slimit
+#define ors_tlimit oq_search.rs_tlimit
+#define ors_attrsonly oq_search.rs_attrsonly
+#define ors_attrs oq_search.rs_attrs
+#define ors_filter oq_search.rs_filter
+#define ors_filterstr oq_search.rs_filterstr
+
+#define orr_newrdn oq_modrdn.rs_newrdn
+#define orr_nnewrdn oq_modrdn.rs_nnewrdn
+#define orr_newSup oq_modrdn.rs_newSup
+#define orr_nnewSup oq_modrdn.rs_nnewSup
+#define orr_deleteoldrdn oq_modrdn.rs_deleteoldrdn
+
+#define orc_ava oq_compare.rs_ava
+#define ora_e oq_add.rs_e
+#define orn_msgid oq_abandon.rs_msgid
+#define orm_modlist oq_modify.rs_modlist
+
+#define ore_reqoid oq_extended.rs_reqoid
+#define ore_reqdata oq_extended.rs_reqdata
 
 	ldap_pvt_thread_t	o_tid;	/* thread handling this op */
 
 	volatile sig_atomic_t o_abandon;	/* abandon flag */
-	volatile sig_atomic_t o_cancel;         /* cancel flag */
+	volatile sig_atomic_t o_cancel;		/* cancel flag */
+#define SLAP_CANCEL_NONE				0x00
+#define SLAP_CANCEL_REQ					0x01
+#define SLAP_CANCEL_ACK					0x02
+#define SLAP_CANCEL_DONE				0x03
 
 	char o_do_not_cache;	/* don't cache from this op */
+	char o_is_auth_check;	/* authorization in progress */
 
 #define SLAP_NO_CONTROL 0
 #define SLAP_NONCRITICAL_CONTROL 1
 #define SLAP_CRITICAL_CONTROL 2
 	char o_managedsait;
+#define get_manageDSAit(op)				((int)(op)->o_managedsait)
+
 	char o_noop;
 	char o_proxy_authz;
+
 	char o_subentries;
+#define get_subentries(op)				((int)(op)->o_subentries)
 	char o_subentries_visibility;
+#define get_subentries_visibility(op)	((int)(op)->o_subentries_visibility)
+
 	char o_valuesreturnfilter;
 
-	char o_permitmodify;
-	char o_noreferrals;
+#ifdef LDAP_CONTROL_X_PERMISSIVE_MODIFY
+	char o_permissive_modify;
+#define get_permissiveModify(op)		((int)(op)->o_permissive_modify)
+#else
+#define get_permissiveModify(op)		(0)
+#endif
+
+#ifdef LDAP_CONTROL_X_DOMAIN_SCOPE
+	char o_domain_scope;
+#define get_domainScope(op)				((int)(op)->o_domain_scope)
+#else
+#define get_domainScope(op)				(0)
+#endif
+
+#ifdef LDAP_CONTROL_PAGEDRESULTS
 	char o_pagedresults;
+#define get_pagedresults(op)			((int)(op)->o_pagedresults)
 	ber_int_t o_pagedresults_size;
 	PagedResultsState o_pagedresults_state;
+#else
+#define get_pagedresults(op)			(0)
+#endif
 
 #ifdef LDAP_CLIENT_UPDATE
 	char o_clientupdate;
@@ -1691,17 +1808,28 @@ typedef struct slap_op {
 #define SLAP_LCUP_NONE				(0x0)
 #define SLAP_LCUP_SYNC 				(0x1)
 #define SLAP_LCUP_PERSIST			(0x2)
-#define SLAP_LCUP_SYNC_AND_PERSIST	(0x3)
+#define SLAP_LCUP_SYNC_AND_PERSIST		(0x3)
 	ber_int_t o_clientupdate_interval;
 	struct berval o_clientupdate_state;
-	LDAP_LIST_HEAD(lss, lcup_search_spec) psearch_spec;
-	LDAP_LIST_HEAD(pe, psid_entry) premodify_list;
-	LDAP_LIST_ENTRY(slap_op) link;
-#endif /* LDAP_CLIENT_UPDATE */
+#endif
 
-#ifdef LDAP_CONNECTIONLESS
-	Sockaddr	o_peeraddr;	/* UDP peer address		  */
+#ifdef LDAP_SYNC
+	char o_sync;
+	char o_sync_mode;
+#define SLAP_SYNC_NONE				(0x0)
+#define SLAP_SYNC_REFRESH			(0x1)
+#define SLAP_SYNC_PERSIST			(0x2)
+#define SLAP_SYNC_REFRESH_AND_PERSIST		(0x3)
+	struct berval o_sync_state;
+#endif
+
+#if defined(LDAP_CLIENT_UPDATE) || defined(LDAP_SYNC)
+	int o_ps_protocol;
+	int o_ps_entries;
+	LDAP_LIST_ENTRY(slap_op) o_ps_link;
+	LDAP_LIST_HEAD(pe, psid_entry) o_pm_list;
 #endif
+
 	AuthorizationInformation o_authz;
 
 	BerElement	*o_ber;		/* ber of the request		  */
@@ -1717,105 +1845,36 @@ typedef struct slap_op {
 	LDAP_STAILQ_ENTRY(slap_op)	o_next;	/* next operation in list	  */
 	ValuesReturnFilter *vrFilter; /* Structure represents ValuesReturnFilter */
 
-	void    *o_pb;                  /* Netscape plugin */
+#ifdef LDAP_CACHING 
+ 	char		o_caching_on; 
+#endif /*LDAP_CACHING */ 
 
+#ifdef LDAP_SLAPI
+	void    *o_pb;                  /* NS-SLAPI plugin */
+#endif
 } Operation;
 
-#define get_manageDSAit(op)				((int)(op)->o_managedsait)
-#define get_subentries(op)				((int)(op)->o_subentries)
-#define get_subentries_visibility(op)	((int)(op)->o_subentries_visibility)
-#define get_pagedresults(op)			((int)(op)->o_pagedresults)
-
-
-
-typedef void (*SEND_LDAP_RESULT)(
-				struct slap_conn *conn,
-				struct slap_op *op,
-				ber_int_t err,
-				const char *matched,
-				const char *text,
-				BerVarray ref,
-				LDAPControl **ctrls
-				);
-
-#define send_ldap_result( conn, op, err, matched, text, ref, ctrls  ) \
-(*conn->c_send_ldap_result)( conn, op, err, matched, text, ref, ctrls )
-
-
-typedef int (*SEND_SEARCH_ENTRY)(
-				struct slap_backend_db *be,
-				struct slap_conn *conn,
-				struct slap_op *op,
-				struct slap_entry *e,
-				AttributeName *attrs,
-				int attrsonly,
-				LDAPControl **ctrls
-				);
-
-#define send_search_entry( be, conn, op, e, attrs, attrsonly, ctrls) \
-(*conn->c_send_search_entry)( be, conn, op, e, attrs, attrsonly, ctrls)
-
-
-typedef void (*SEND_SEARCH_RESULT)(
-				struct slap_conn *conn,
-				struct slap_op *op,
-				ber_int_t err,
-				const char *matched,
-				const char *text,
-				BerVarray   refs,
-				LDAPControl **ctrls,
-				int nentries
-				);
-
-#define send_search_result( conn, op, err, matched, text, refs, ctrls, nentries ) \
-(*conn->c_send_search_result)( conn, op, err, matched, text, refs, ctrls, nentries )
-
-
-typedef int (*SEND_SEARCH_REFERENCE)(
-				struct slap_backend_db *be,
-				struct slap_conn *conn,
-				struct slap_op *op,
-				struct slap_entry *e,
-				BerVarray refs,
-				LDAPControl **ctrls,
-				BerVarray *v2refs
-				);
-
-#define send_search_reference( be, conn, op, e,  refs, ctrls, v2refs ) \
-(*conn->c_send_search_reference)( be, conn, op, e,  refs, ctrls, v2refs )
-
-
-typedef void (*SEND_LDAP_EXTENDED)(
-				struct slap_conn *conn,
-				struct slap_op *op,
-				ber_int_t   err,
-				const char  *matched,
-				const char  *text,
-				BerVarray   refs,
-				const char      *rspoid,
-				struct berval *rspdata,
-				LDAPControl **ctrls
-				);
-
-#define send_ldap_extended( conn, op, err, matched, text, refs, rspoid, rspdata, ctrls) \
-(*conn->c_send_ldap_extended)( conn, op, err, matched, text, refs, rspoid, rspdata, ctrls )
-
-typedef void (*SEND_LDAP_INTERMEDIATE_RESP)(
-				struct slap_conn *conn,
-				struct slap_op *op,
-				ber_int_t   err,
-				const char  *matched,
-				const char  *text,
-				BerVarray   refs,
-				const char      *rspoid,
-				struct berval *rspdata,
-				LDAPControl **ctrls
-				);
-
-#define send_ldap_intermediate_resp( conn, op, err, matched, text, refs, \
-				     rspoid, rspdata, ctrls) \
-	(*conn->c_send_ldap_intermediate_resp)( conn, op, err, matched, text, \
-						refs, rspoid, rspdata, ctrls )
+#define send_ldap_error( op, rs, err, text ) \
+do { (rs)->sr_err = err; (rs)->sr_text = text; \
+(op->o_conn->c_send_ldap_result)( op, rs ); } while (0)
+#define send_ldap_discon( op, rs, err, text ) \
+do { (rs)->sr_err = err; (rs)->sr_text = text; \
+send_ldap_disconnect( op, rs ); } while (0)
+typedef void (SEND_LDAP_RESULT)(struct slap_op *op, struct slap_rep *rs);
+typedef int (SEND_SEARCH_ENTRY)(struct slap_op *op, struct slap_rep *rs);
+typedef int (SEND_SEARCH_REFERENCE)(struct slap_op *op, struct slap_rep *rs);
+typedef void (SEND_LDAP_EXTENDED)(struct slap_op *op, struct slap_rep *rs);
+typedef void (SEND_LDAP_INTERMEDIATE_RESP)(struct slap_op *op, struct slap_rep *rs);
+#define send_ldap_result( op, rs ) \
+(op->o_conn->c_send_ldap_result)( op, rs )
+#define send_search_entry( op, rs ) \
+(op->o_conn->c_send_search_entry)( op, rs )
+#define send_search_reference( op, rs ) \
+(op->o_conn->c_send_search_reference)( op, rs )
+#define send_ldap_extended( op, rs ) \
+(op->o_conn->c_send_ldap_extended)( op, rs )
+#define send_ldap_intermediate_resp( op, rs ) \
+(op->o_conn->c_send_ldap_intermediate_resp)( op, rs )
 
 /*
  * Caches the result of a backend_group check for ACL evaluation
@@ -1905,12 +1964,13 @@ typedef struct slap_conn {
 	 * supply data back to connected clients that are connected
 	 * through the "front-end".
 	 */
-	SEND_LDAP_RESULT c_send_ldap_result;
-	SEND_SEARCH_ENTRY c_send_search_entry;
-	SEND_SEARCH_RESULT c_send_search_result;
-	SEND_SEARCH_REFERENCE c_send_search_reference;
-	SEND_LDAP_EXTENDED c_send_ldap_extended;
-	SEND_LDAP_INTERMEDIATE_RESP c_send_ldap_intermediate_resp;
+	SEND_LDAP_RESULT *c_send_ldap_result;
+	SEND_SEARCH_ENTRY *c_send_search_entry;
+	SEND_SEARCH_REFERENCE *c_send_search_reference;
+	SEND_LDAP_EXTENDED *c_send_ldap_extended;
+#ifdef LDAP_RES_INTERMEDIATE_RESP
+	SEND_LDAP_INTERMEDIATE_RESP *c_send_ldap_intermediate_resp;
+#endif
 	
 } Connection;
 
@@ -1931,14 +1991,6 @@ typedef struct slap_conn {
 			fprintf( stderr, (fmt), (connid), (opid), (arg1), (arg2), (arg3) );\
 	} while (0)
 #define StatslogTest( level ) (ldap_debug & (level))
-#elif defined(LDAP_SYSLOG)
-#define Statslog( level, fmt, connid, opid, arg1, arg2, arg3 )	\
-	do { \
-		if ( ldap_syslog & (level) ) \
-			syslog( ldap_syslog_level, (fmt), (connid), (opid), (arg1), \
-				(arg2), (arg3) ); \
-	} while (0)
-#define StatslogTest( level ) (ldap_syslog & (level))
 #else
 #define Statslog( level, fmt, connid, opid, arg1, arg2, arg3 )
 #define StatslogTest( level ) (0)
@@ -1997,6 +2049,34 @@ enum {
 #define SLAP_LCUP_ENTRY_DELETED_FALSE	0
 #endif /* LDAP_CLIENT_UPDATE */
 
+#if defined(LDAP_CLIENT_UPDATE) || defined(LDAP_SYNC)
+#define SLAP_SEARCH_MAX_CTRLS   10
+#endif
+
+#define SLAP_CTRL_FRONTEND			0x80000000U
+#define SLAP_CTRL_FRONTEND_SEARCH	0x01000000U	/* for NOOP */
+
+#define SLAP_CTRL_OPFLAGS			0x0000FFFFU
+#define SLAP_CTRL_ABANDON			0x00000001U
+#define SLAP_CTRL_ADD				0x00002002U
+#define SLAP_CTRL_BIND				0x00000004U
+#define SLAP_CTRL_COMPARE			0x00001008U
+#define SLAP_CTRL_DELETE			0x00002010U
+#define SLAP_CTRL_MODIFY			0x00002020U
+#define SLAP_CTRL_RENAME			0x00002040U
+#define SLAP_CTRL_SEARCH			0x00001080U
+#define SLAP_CTRL_UNBIND			0x00000100U
+
+#define SLAP_CTRL_INTROGATE	(SLAP_CTRL_COMPARE|SLAP_CTRL_SEARCH)
+#define SLAP_CTRL_UPDATE \
+	(SLAP_CTRL_ADD|SLAP_CTRL_DELETE|SLAP_CTRL_MODIFY|SLAP_CTRL_RENAME)
+#define SLAP_CTRL_ACCESS	(SLAP_CTRL_INTROGATE|SLAP_CTRL_UPDATE)
+
+typedef int (SLAP_CTRL_PARSE_FN) LDAP_P((
+	Operation *op,
+	SlapReply *rs,
+	LDAPControl *ctrl ));
+
 LDAP_END_DECL
 
 #include "proto-slap.h"