Moving NSCP Directory Server from DirectoryBranch to TRUNK, initial drop. (foxworth)ldapserver7x

1 files changed, 3124 insertions, 0 deletions

diff --git a/ldap/servers/slapd/entry.c b/ldap/servers/slapd/entry.c
new file mode 100644
index 00000000..0d315053
--- /dev/null
+++ b/ldap/servers/slapd/entry.c
@@ -0,0 +1,3124 @@
+/** BEGIN COPYRIGHT BLOCK
+ * Copyright 2001 Sun Microsystems, Inc.
+ * Portions copyright 1999, 2001-2003 Netscape Communications Corporation.
+ * All rights reserved.
+ * END COPYRIGHT BLOCK **/
+/* entry.c - routines for dealing with entries */
+
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <sys/types.h>
+#ifndef _WIN32
+#include <sys/socket.h>
+#endif
+#undef DEBUG                    /* disable counters */
+#include <prcountr.h>
+#include "slap.h"
+
+
+#undef ENTRY_DEBUG
+
+#define DELETED_ATTR_STRING ";deletedattribute"
+#define DELETED_ATTR_STRSIZE 17 /* sizeof(";deletedattribute") */
+#define DELETED_VALUE_STRING ";deleted"
+#define DELETED_VALUE_STRSIZE 8 /* sizeof(";deleted") */
+
+/*
+ * An attribute name is of the form 'basename[;option]'.
+ * The state informaion is encoded in options. For example:
+ *
+ * telephonenumber;vucsn-011111111222233334444: 1 650 937 5739
+ *
+ * This function strips out the csn options, leaving behind a
+ * type with any non-csn options left intact.
+ */
+/*
+ * WARNING: s gets butchered... the base type remains.
+ */
+void
+str2entry_state_information_from_type(char *s,CSNSet **csnset,CSN **attributedeletioncsn,CSN **maxcsn,int *value_state,int *attr_state)
+{
+	char *p= strchr(s, ';');
+	*value_state= VALUE_PRESENT;
+	*attr_state= ATTRIBUTE_PRESENT;
+	while(p!=NULL)
+	{
+		if(p[3]=='c' && p[4]=='s' && p[5]=='n' && p[6]=='-')
+		{
+			CSNType t= CSN_TYPE_UNKNOWN;
+			if(p[1]=='x' && p[2]=='1')
+			{
+				t= CSN_TYPE_UNKNOWN;
+			}
+			if(p[1]=='x' && p[2]=='2')
+			{
+				t= CSN_TYPE_NONE;
+			}
+			if(p[1]=='a' && p[2]=='d')
+			{
+				t= CSN_TYPE_ATTRIBUTE_DELETED;
+			}
+			if(p[1]=='v' && p[2]=='u')
+			{
+				t= CSN_TYPE_VALUE_UPDATED;
+			}
+			if(p[1]=='v' && p[2]=='d')
+			{
+				t= CSN_TYPE_VALUE_DELETED;
+			}
+			if(p[1]=='m' && p[2]=='d')
+			{
+				t= CSN_TYPE_VALUE_DISTINGUISHED;
+			}
+			p[0]='\0';
+			if(t!=CSN_TYPE_ATTRIBUTE_DELETED)
+			{
+				CSN csn;
+				csn_init_by_string(&csn,p+7);
+				csnset_add_csn(csnset,t,&csn);
+				if ( *maxcsn == NULL )
+				{
+					*maxcsn = csn_dup ( &csn );
+				}
+				else if ( csn_compare (*maxcsn, &csn) < 0 )
+				{
+					csn_init_by_csn ( *maxcsn, &csn );
+				}
+			}
+			else
+			{
+				*attributedeletioncsn= csn_new_by_string(p+7);
+				if ( *maxcsn == NULL )
+				{
+					*maxcsn = csn_dup ( *attributedeletioncsn );
+				}
+				else if ( csn_compare (*maxcsn, *attributedeletioncsn) < 0 )
+				{
+					csn_init_by_csn ( *maxcsn, *attributedeletioncsn );
+				}
+			}
+		}
+		else if(strncmp(p+1,"deletedattribute", 16)==0)
+		{
+			p[0]='\0';
+			*attr_state= ATTRIBUTE_DELETED;
+		}
+		else if(strncmp(p+1,"deleted", 7)==0)
+		{
+			p[0]='\0';
+			*value_state= VALUE_DELETED;
+		}
+		p= strchr(p+1, ';');
+	}
+}
+
+
+static Slapi_Entry *
+str2entry_fast( char *s, int flags, int read_stateinfo )
+{
+	Slapi_Entry	*e;
+	char		*next, *ptype=NULL;
+	int nvals= 0;
+	int del_nvals= 0;
+	int retmalloc = 0;
+	unsigned long attr_val_cnt = 0;
+	CSN *attributedeletioncsn= NULL; /* Moved to this level so that the JCM csn_free call below gets useful */
+	CSNSet *valuecsnset= NULL; /* Moved to this level so that the JCM csn_free call below gets useful */
+	CSN *maxcsn = NULL;
+
+	/*
+	 * In string format, an entry looks like this:
+	 *
+	 *	dn: <dn>\n
+	 *	[<attr>:[:] <value>\n]
+	 *	[<tab><continuedvalue>\n]*
+	 *	...
+	 *
+	 * If a double colon is used after a type, it means the
+	 * following value is encoded as a base 64 string.  This
+	 * happens if the value contains a non-printing character
+	 * or newline.
+	 */
+
+	LDAPDebug( LDAP_DEBUG_TRACE, "=> str2entry_fast\n", 0, 0, 0 );
+
+	e = slapi_entry_alloc();
+	slapi_entry_init(e,NULL,NULL);
+
+	/* dn + attributes */
+	next = s;
+
+	/* get the read lock of name2asi for performance purpose.
+	   It reduces read locking by per-entry lock, instead of per-attribute.
+	*/
+	attr_syntax_read_lock();
+
+	while ( (s = ldif_getline( &next )) != NULL &&
+	         attr_val_cnt < ENTRY_MAX_ATTRIBUTE_VALUE_COUNT )
+	{
+		Slapi_Attr **a;
+		char *valuecharptr=NULL;
+		int	valuelen;
+		CSNType attributecsntype;
+		int value_state= VALUE_NOTFOUND;
+		int attr_state= ATTRIBUTE_NOTFOUND;
+		int maxvals;
+		int del_maxvals;
+		char *type;
+		char *errmsg = NULL;
+
+		if ( *s == '\n' || *s == '\0' ) {
+			break;
+		}
+
+		if ( (retmalloc = ldif_parse_line( s, &type, &valuecharptr, &valuelen, &errmsg )) < 0 ) {
+			if ( errmsg != NULL ) {
+			         LDAPDebug( LDAP_DEBUG_PARSE, "%s", errmsg, 0, 0 );
+				 /* the memory below was not allocated by the slapi_ch_ functions */
+				 slapi_ch_free( (void**)&errmsg );
+			}
+			LDAPDebug( LDAP_DEBUG_TRACE,
+			    "<= str2entry_fast NULL (parse_line)\n", 0, 0, 0 );
+			continue;
+		}
+
+		/* We don't use errmsg anywhere later. free it to avoid leaking... */
+		/* the memory below was not allocated by the slapi_ch_ functions */
+		slapi_ch_free( (void**)&errmsg );
+
+		/*
+		 * Extract the attribute and value CSNs from the attribute type.
+		 */		
+		attributecsntype= CSN_TYPE_NONE;
+		csn_free(&attributedeletioncsn); /* JCM - Do this more efficiently */
+		csnset_free(&valuecsnset);
+		value_state= VALUE_NOTFOUND;
+		attr_state= ATTRIBUTE_NOTFOUND;
+		str2entry_state_information_from_type(type,&valuecsnset,&attributedeletioncsn,&maxcsn,&value_state,&attr_state);
+		if(!read_stateinfo)
+		{
+			/* We are not maintaining state information */
+			if(value_state==VALUE_DELETED || attr_state==ATTRIBUTE_DELETED)
+			{
+				/* ignore deleted values and attributes */
+				/* the memory below was not allocated by the slapi_ch_ functions */
+				if (retmalloc) slapi_ch_free((void **) &valuecharptr);
+				continue;
+			}
+			/* Ignore CSNs */
+			csn_free(&attributedeletioncsn);
+			csnset_free(&valuecsnset);
+		}
+		/*
+		 * We cache some stuff as we go around the loop.
+		 */
+		if((ptype==NULL)||(strcasecmp(type,ptype) != 0))
+		{
+			ptype=type;
+			nvals = 0;
+			maxvals = 0;
+			del_nvals = 0;
+			del_maxvals = 0;
+			a = NULL;
+		}
+
+		if ( strcasecmp( type, "dn" ) == 0 )
+		{
+			if ( slapi_entry_get_dn_const(e)!=NULL )
+			{
+				char ebuf[ BUFSIZ ];
+				LDAPDebug( LDAP_DEBUG_ANY,
+				    "str2entry_fast: entry has multiple dns \"%s\" and \"%s\" (second ignored)\n",
+				    escape_string( slapi_entry_get_dn_const(e), ebuf ),
+				    escape_string( valuecharptr, ebuf ), 0 );
+				    /* the memory below was not allocated by the slapi_ch_ functions */
+				if (retmalloc) slapi_ch_free((void **) &valuecharptr);
+				continue;
+			}
+			slapi_entry_set_dn(e,slapi_ch_strdup( valuecharptr ));
+			/* the memory below was not allocated by the slapi_ch_ functions */
+			if (retmalloc) slapi_ch_free((void **) &valuecharptr);
+			continue;
+		}
+
+		/* retrieve uniqueid */
+		if ( strcasecmp (type, SLAPI_ATTR_UNIQUEID) == 0 ){
+
+			if (e->e_uniqueid != NULL){
+				LDAPDebug (LDAP_DEBUG_ANY, "str2entry_fast: entry has multiple "
+						   "uniqueids %s and %s (second ignored)\n",
+						   e->e_uniqueid, valuecharptr, 0);
+			}else{
+				/* name2asi will be locked in slapi_entry_set_uniqueid */
+				attr_syntax_unlock_read(); 
+				slapi_entry_set_uniqueid (e, slapi_ch_strdup(valuecharptr));
+				attr_syntax_read_lock();
+			}
+			/* the memory below was not allocated by the slapi_ch_ functions */
+			if (retmalloc) slapi_ch_free((void **) &valuecharptr);
+			continue;
+		}
+		
+		if (strcasecmp(type,"objectclass") == 0) {
+			if (strcasecmp(valuecharptr,"ldapsubentry") == 0)
+				e->e_flags |= SLAPI_ENTRY_LDAPSUBENTRY;
+			if (strcasecmp(valuecharptr, SLAPI_ATTR_VALUE_TOMBSTONE) == 0)
+				e->e_flags |= SLAPI_ENTRY_FLAG_TOMBSTONE;
+		}
+		
+		{
+			Slapi_Value	*value= value_new(NULL,CSN_TYPE_NONE,NULL);
+			slapi_value_set( value, valuecharptr, valuelen );
+			/* the memory below was not allocated by the slapi_ch_ functions */	
+		if (retmalloc) slapi_ch_free((void **) &valuecharptr);
+			value->v_csnset= valuecsnset;
+			valuecsnset= NULL;
+			if(a==NULL)
+			{
+				switch(attr_state)
+				{
+				case ATTRIBUTE_PRESENT:
+					if(attrlist_find_or_create_locking_optional(&e->e_attrs, type, &a, PR_FALSE, PR_TRUE)==0 /* Found */)
+					{
+						LDAPDebug (LDAP_DEBUG_ANY, "str2entry_fast: Error. Non-contiguous attribute values for %s\n", type, 0, 0);
+						PR_ASSERT(0);
+						continue;
+					}
+					break;
+				case ATTRIBUTE_DELETED:
+					if(attrlist_find_or_create_locking_optional(&e->e_deleted_attrs, type, &a, PR_FALSE, PR_TRUE)==0 /* Found */)
+					{
+						LDAPDebug (LDAP_DEBUG_ANY, "str2entry_fast: Error. Non-contiguous deleted attribute values for %s\n", type, 0, 0);
+						PR_ASSERT(0);
+						continue;
+					}
+					break;
+				case ATTRIBUTE_NOTFOUND:
+					LDAPDebug (LDAP_DEBUG_ANY, "str2entry_fast: Error. Non-contiguous deleted attribute values for %s\n", type, 0, 0);
+					PR_ASSERT(0);
+					continue;
+					/* break; ??? */
+				}
+
+			}
+			{
+				const CSN *distinguishedcsn= csnset_get_csn_of_type(value->v_csnset,CSN_TYPE_VALUE_DISTINGUISHED);
+				if(distinguishedcsn!=NULL)
+				{
+					entry_add_dncsn_ext(e,distinguishedcsn, ENTRY_DNCSN_INCREASING);
+				}
+			}
+			if(value_state==VALUE_DELETED)
+			{
+				/* consumes the value */
+				valuearray_add_value_fast(
+					&(*a)->a_deleted_values.va, /* JCM .va is private */
+					value,
+					del_nvals,
+					&del_maxvals,
+					0/*!Exact*/,
+					1/*Passin*/ );
+				del_nvals++;
+			}
+			else
+			{
+				/* consumes the value */
+				valuearray_add_value_fast(
+					&(*a)->a_present_values.va, /* JCM .va is private */
+					value, 
+					nvals,
+					&maxvals, 
+					0 /*!Exact*/, 
+					1 /*Passin*/ );
+				nvals++;
+			}
+			if(attributedeletioncsn!=NULL)
+			{
+				attr_set_deletion_csn(*a,attributedeletioncsn);
+			}
+		}
+		csn_free(&attributedeletioncsn);
+		csnset_free(&valuecsnset);
+		attr_val_cnt++;
+	}
+	if ( attr_val_cnt >= ENTRY_MAX_ATTRIBUTE_VALUE_COUNT )
+	{
+		LDAPDebug( LDAP_DEBUG_ANY,
+		    "str2entry_fast: entry %s exceeded max attribute value cound %ld\n",
+			slapi_entry_get_dn_const(e)?slapi_entry_get_dn_const(e):"unkown",
+			attr_val_cnt, 0 );
+	}
+	if (read_stateinfo && maxcsn)
+	{
+		e->e_maxcsn = maxcsn;
+	}
+
+	/* release read lock of name2asi, per-entry lock */
+	attr_syntax_unlock_read();
+
+	/* check to make sure there was a dn: line */
+	if ( slapi_entry_get_dn_const(e)==NULL ) {
+		if (!(SLAPI_STR2ENTRY_INCLUDE_VERSION_STR & flags))
+			LDAPDebug( LDAP_DEBUG_ANY, "str2entry_fast: entry has no dn\n",
+									   0, 0, 0 );
+		slapi_entry_free( e );
+		return( NULL );
+	}
+
+	LDAPDebug( LDAP_DEBUG_TRACE, "<= str2entry_fast 0x%x\n",
+		e, 0, 0 );
+	return( e );
+}
+
+
+#define	STR2ENTRY_SMALL_BUFFER_SIZE	64
+#define STR2ENTRY_INITIAL_BERVAL_ARRAY_SIZE 8
+#define STR2ENTRY_VALUE_DUPCHECK_THRESHOLD 5
+
+typedef struct _entry_attr_data {
+	int			ead_attrarrayindex;
+	const char	*ead_attrtypename;
+	char		ead_allocated;	/* non-zero if this struct needs to be freed */
+} entry_attr_data;
+
+/* Structure which stores a tree for the attributes on the entry rather than the linked list on a regular entry struture */
+typedef struct _entry_attrs {
+	Avlnode				*ea_attrlist;
+	int					ea_attrdatacount;
+	entry_attr_data		ea_attrdata[ STR2ENTRY_SMALL_BUFFER_SIZE ];
+} entry_attrs;
+
+typedef struct _str2entry_attr {
+	char *sa_type;
+	int sa_state;
+ 	struct valuearrayfast sa_present_values;
+ 	struct valuearrayfast sa_deleted_values;
+	int sa_numdups;
+	struct slapdplugin *sa_pi;
+	value_compare_fn_type sa_comparefn;
+	Avlnode *sa_vtree;
+	CSN *sa_attributedeletioncsn;
+} str2entry_attr;
+
+static void
+entry_attr_init(str2entry_attr *sa, const char *type, int state)
+{
+    sa->sa_type= slapi_ch_strdup(type);
+	sa->sa_state= state;
+	valuearrayfast_init(&sa->sa_present_values,NULL);
+	valuearrayfast_init(&sa->sa_deleted_values,NULL);
+    sa->sa_numdups= 0;
+	sa->sa_pi= NULL;
+	sa->sa_comparefn = NULL;
+    sa->sa_vtree= NULL;
+	sa->sa_attributedeletioncsn= NULL;
+}
+
+/*
+ * Create a tree of attributes.
+ */
+static int
+entry_attrs_new(entry_attrs **pea)
+{
+	entry_attrs *tmp = (entry_attrs *)slapi_ch_calloc(1, sizeof(entry_attrs));
+	if (NULL == tmp) {
+		return -1;
+	} else {
+		*pea = tmp;
+		return 0;
+	}
+}
+
+/*
+ * Delete an attribute type tree node.
+ */
+static void
+attr_type_node_free( caddr_t data )
+{
+	entry_attr_data	*ea = (entry_attr_data *)data;
+	if ( NULL != ea && ea->ead_allocated ) {
+		slapi_ch_free( (void **)&ea );
+	}
+}
+
+
+/*
+ * Delete a tree of attributes.
+ */
+static void
+entry_attrs_delete(entry_attrs **pea)
+{
+	if (NULL != *pea) {
+		/* Delete the AVL tree */
+		avl_free((*pea)->ea_attrlist, attr_type_node_free);
+		slapi_ch_free((void**)pea);
+	}
+}
+
+static int
+attr_type_node_cmp( caddr_t d1, caddr_t d2 )
+{
+	/*
+	 * A simple strcasecmp() will do here because we do not care
+	 * about subtypes, etc. The slapi_str2entry() function treats
+	 * subtypes as distinct attribute types, because that is how
+	 * they are stored within the Slapi_Entry structure.
+	 */
+	entry_attr_data *ea1= (entry_attr_data *)d1;
+	entry_attr_data *ea2= (entry_attr_data *)d2;
+	PR_ASSERT( ea1 != NULL );
+	PR_ASSERT( ea1->ead_attrtypename != NULL );
+	PR_ASSERT( ea2 != NULL );
+	PR_ASSERT( ea2->ead_attrtypename != NULL );
+	return strcasecmp(ea1->ead_attrtypename,ea2->ead_attrtypename);
+}
+
+/*
+ * Adds a new attribute to the attribute tree.
+ */
+static void
+entry_attrs_add(entry_attrs *ea, const char *atname, int atarrayindex)
+{
+	entry_attr_data	*ead;
+
+	if ( ea->ea_attrdatacount < STR2ENTRY_SMALL_BUFFER_SIZE ) {
+		ead = &(ea->ea_attrdata[ ea->ea_attrdatacount ]);
+		ead->ead_allocated = 0;
+	} else {
+		ead = (entry_attr_data *)slapi_ch_malloc( sizeof( entry_attr_data ));
+		ead->ead_allocated = 1;
+	}
+	++ea->ea_attrdatacount;
+	ead->ead_attrarrayindex = atarrayindex;
+	ead->ead_attrtypename = atname;	/* a reference, not a strdup! */
+		
+	avl_insert( &(ea->ea_attrlist), ead, attr_type_node_cmp, avl_dup_error );
+}
+
+/*
+ * Checks for an attribute in the tree.  Returns the attr array index or -1
+ * if not found;
+ */
+static int
+entry_attrs_find(entry_attrs *ea,char *type)
+{
+	entry_attr_data	tmpead = {0};
+	entry_attr_data	*foundead;
+
+	tmpead.ead_attrtypename = type;
+	foundead = (entry_attr_data *)avl_find( ea->ea_attrlist, &tmpead,
+				attr_type_node_cmp );
+	return ( NULL != foundead ) ? foundead->ead_attrarrayindex : -1;
+}
+
+/* What's going on here then ? 
+   Well, originally duplicate value checking was done by taking each
+   new value and comparing in turn against all the previous values.
+   Needless to say this was costly when there were many values.
+   So, new code was written which built a binary tree of index keys
+   for the values, and the test was done against the tree.
+   Nothing wrong with this, it speeded up the case where there were
+   many values nicely.
+   Unfortunately, when there are few values, it proved to be a significent 
+   performance sink. 
+   So, now we check the old way up 'till there's 5 attribute values, then
+   switch to the tree-based scheme.
+
+   Note that duplicate values are only checked for and ignored
+   if flags contains SLAPI_STR2ENTRY_REMOVEDUPVALS.
+ */
+
+static Slapi_Entry *
+str2entry_dupcheck( char *s, int flags, int read_stateinfo )
+{
+    Slapi_Entry	*e;
+    str2entry_attr stack_attrs[STR2ENTRY_SMALL_BUFFER_SIZE];
+    str2entry_attr *dyn_attrs = NULL;
+    str2entry_attr *attrs = stack_attrs;
+    str2entry_attr *prev_attr= NULL;
+    int nattrs;
+    int maxattrs = STR2ENTRY_SMALL_BUFFER_SIZE;
+    char *type;
+    str2entry_attr *sa;
+    int i, j;
+    char *next=NULL;
+    char *valuecharptr=NULL;
+    char *errmsg = NULL;
+    int retmalloc = 0;
+    int rc;
+	int fast_dup_check = 0;
+	entry_attrs *ea = NULL;
+	int tree_attr_checking = 0;
+	int big_entry_attr_presence_check = 0;
+	int check_for_duplicate_values =
+			( 0 != ( flags & SLAPI_STR2ENTRY_REMOVEDUPVALS ));
+	Slapi_Value *value = 0;
+	CSN *maxcsn= NULL;
+
+	LDAPDebug( LDAP_DEBUG_TRACE, "=> str2entry_dupcheck\n", 0, 0, 0 );
+
+    e = slapi_entry_alloc();
+    slapi_entry_init(e,NULL,NULL);
+    next = s;
+    nattrs = 0;
+
+	if (flags & SLAPI_STR2ENTRY_BIGENTRY)
+	{
+		big_entry_attr_presence_check = 1;
+	}
+    while ( (s = ldif_getline( &next )) != NULL )
+    {
+		CSN *attributedeletioncsn= NULL;
+		CSNType attributecsntype;
+		CSNSet *valuecsnset= NULL;
+		int value_state= VALUE_NOTFOUND;
+		int attr_state= VALUE_NOTFOUND;
+		int valuelen;
+
+		if ( *s == '\n' || *s == '\0' ) {
+		    break;
+		}
+
+		if ( (retmalloc = ldif_parse_line( s, &type, &valuecharptr, &valuelen, &errmsg )) < 0 ) {
+		    if ( errmsg != NULL ) {
+		             LDAPDebug( LDAP_DEBUG_PARSE, "%s", errmsg, 0, 0 );
+			     /* the memory below was not allocated by the slapi_ch_ functions */
+			     slapi_ch_free( (void**)&errmsg );
+		    }
+		    LDAPDebug( LDAP_DEBUG_TRACE,
+			    "<= slapi_str2entry NULL (parse_line)\n", 0, 0, 0 );
+		    continue;
+		}
+
+		/* We don't use errmsg anywhere later. free it to avoid leaking... */
+		/* the memory below was not allocated by the slapi_ch_ functions */
+		slapi_ch_free( (void**)&errmsg );
+
+		/*
+		 * Extract the attribute and value CSNs from the attribute type.
+		 */		
+		attributecsntype= CSN_TYPE_UNKNOWN;
+		csn_free(&attributedeletioncsn);
+		csnset_free(&valuecsnset);
+		value_state= VALUE_NOTFOUND;
+		attr_state= VALUE_NOTFOUND;
+		str2entry_state_information_from_type(type,&valuecsnset,&attributedeletioncsn,&maxcsn,&value_state,&attr_state);
+		if(!read_stateinfo)
+		{
+			/* We are not maintaining state information */
+			if(value_state==VALUE_DELETED || attr_state==ATTRIBUTE_DELETED)
+			{
+				/* ignore deleted values and attributes */
+				/* the memory below was not allocated by the slapi_ch_ functions */
+				if (retmalloc) slapi_ch_free((void **) &valuecharptr);
+				continue;
+			}
+			/* Ignore CSNs */
+			csn_free(&attributedeletioncsn);
+			csnset_free(&valuecsnset);
+		}
+
+		if ( strcasecmp( type, "dn" ) == 0 ) {
+		    if ( slapi_entry_get_dn_const(e)!=NULL ) {
+				char ebuf[ BUFSIZ ];
+				LDAPDebug( LDAP_DEBUG_ANY,
+					"slapi_str2entry: entry has multiple dns \"%s\" and \"%s\" (second ignored)\n",
+					escape_string( slapi_entry_get_dn_const(e), ebuf ),
+					escape_string( valuecharptr, ebuf ), 0 );
+				/* the memory below was not allocated by the slapi_ch_ functions */
+				if (retmalloc) slapi_ch_free((void **) &valuecharptr);
+				continue;
+		    }
+			slapi_entry_set_dn(e,slapi_ch_strdup( valuecharptr ));
+			/* the memory below was not allocated by the slapi_ch_ functions */
+			if (retmalloc) slapi_ch_free((void **) &valuecharptr);
+		    continue;
+		}
+
+		/* retrieve uniqueid */
+		if ( strcasecmp (type, SLAPI_ATTR_UNIQUEID) == 0 ){
+
+			if (e->e_uniqueid != NULL){
+				LDAPDebug (LDAP_DEBUG_ANY, "slapi_str2entry: entry has multiple "
+						   "uniqueids %s and %s (second ignored)\n", 
+						   e->e_uniqueid, valuecharptr, 0);
+			}else{
+				slapi_entry_set_uniqueid (e, slapi_ch_strdup(valuecharptr));
+			}
+			/* the memory below was not allocated by the slapi_ch_ functions */
+			if (retmalloc) slapi_ch_free((void **) &valuecharptr);
+			continue;
+		}
+
+		if (strcasecmp(type,"objectclass") == 0) {
+			if (strcasecmp(valuecharptr,"ldapsubentry") == 0)
+				e->e_flags |= SLAPI_ENTRY_LDAPSUBENTRY;
+			if (strcasecmp(valuecharptr, SLAPI_ATTR_VALUE_TOMBSTONE) == 0)
+				e->e_flags |= SLAPI_ENTRY_FLAG_TOMBSTONE;
+		}
+
+		/* Here we have a quick look to see if this attribute is a new
+		   value for the type we last processed or a new type.
+		   If not, we look to see if we've seen this attribute type before.
+		*/
+		if ( prev_attr!=NULL && strcasecmp( type, prev_attr->sa_type ) != 0 )
+		{
+		    /* Different attribute type - find it, or alloc new */
+		    prev_attr = NULL;
+			/* The linear check below can take a while, so we change to use a tree if there are many attrs */
+			if (!big_entry_attr_presence_check)
+			{
+			    for ( i = 0; i < nattrs; i++ )
+			    {
+					if (strcasecmp( type, attrs[i].sa_type ) == 0 )
+					{
+					    prev_attr = &attrs[i];
+					    break;
+					}
+			    }
+			}
+			else
+			{
+				int	prev_index;
+
+				/* Did we just switch checking mechanism ? */
+				if (!tree_attr_checking)
+				{
+					/* If so then put the exising attrs into the tree */
+					if (0 != entry_attrs_new(&ea))
+					{
+						/* Something very bad happened */
+						return NULL;
+					}
+					for ( i = 0; i < nattrs; i++ )
+					{
+						entry_attrs_add(ea,attrs[i].sa_type, i);
+					}
+					tree_attr_checking = 1;
+				}
+				prev_index = entry_attrs_find(ea,type);
+				if ( prev_index >= 0 ) {
+					prev_attr = &attrs[prev_index];
+					/* (prev_attr!=NULL) Means that we already had that one in the set */
+				}
+			}
+		}
+		if ( prev_attr==NULL )
+		{
+		    /* Haven't seen this type yet */
+			fast_dup_check = 1;
+		    if ( nattrs == maxattrs )
+		    {
+				/* Out of space - reallocate */
+				maxattrs *= 2;
+				if ( nattrs == STR2ENTRY_SMALL_BUFFER_SIZE ) {
+				    /* out of fixed space - switch to dynamic */
+				    PR_ASSERT( dyn_attrs == NULL );
+				    dyn_attrs = (str2entry_attr *)
+					    slapi_ch_malloc( sizeof( str2entry_attr ) *
+					    maxattrs );
+				    memcpy( dyn_attrs, stack_attrs,
+					    STR2ENTRY_SMALL_BUFFER_SIZE *
+					    sizeof( str2entry_attr ));
+				    attrs = dyn_attrs;
+				} else {
+				    /* Need more dynamic space */
+				    dyn_attrs = (str2entry_attr *)
+					    slapi_ch_realloc( (char *) dyn_attrs, 
+					    sizeof( str2entry_attr ) * maxattrs );
+					attrs = dyn_attrs; /* realloc may change base pointer */
+				}
+		    }
+
+		    /* Record the new type in the array */
+			entry_attr_init(&attrs[nattrs], type, attr_state);
+
+			if ( check_for_duplicate_values )
+			{
+				if ( slapi_attr_type2plugin( type,(void **)&(attrs[nattrs].sa_pi) ) != 0 )
+				{
+					LDAPDebug( LDAP_DEBUG_ANY,
+						"<= slapi_str2entry NULL (slapi_attr_type2plugin)\n",
+						0, 0, 0 );
+					slapi_entry_free( e ); e = NULL;
+					goto free_and_return;
+				}
+				/* Get the comparison function for later use */
+				plugin_call_syntax_get_compare_fn( attrs[nattrs].sa_pi, &(attrs[nattrs].sa_comparefn));
+				/*
+				 * If the compare function wasn't available,
+				 * we have to revert to AVL-tree-based dup checking,
+				 * which uses index keys for comparisons
+				 */
+				if (NULL == attrs[nattrs].sa_comparefn)
+				{
+					fast_dup_check = 0;
+				}
+				/*
+				 * If we are maintaining the attribute tree,
+				 * then add the new attribute to the tree.
+				 */
+				if (big_entry_attr_presence_check && tree_attr_checking)
+				{
+					entry_attrs_add(ea,attrs[nattrs].sa_type, nattrs);
+				}
+			}
+			prev_attr = &attrs[nattrs];
+			nattrs++;
+		}
+
+		sa = prev_attr;	/* For readability */
+		value= value_new(NULL,CSN_TYPE_NONE,NULL);
+		slapi_value_set( value, valuecharptr, valuelen );
+		/* the memory below was not allocated by the slapi_ch_ functions */
+		if (retmalloc) slapi_ch_free((void **) &valuecharptr);
+		value->v_csnset= valuecsnset;
+		valuecsnset= NULL;
+		{
+			const CSN *distinguishedcsn= csnset_get_csn_of_type(value->v_csnset,CSN_TYPE_VALUE_DISTINGUISHED);
+			if(distinguishedcsn!=NULL)
+			{
+				entry_add_dncsn(e,distinguishedcsn);
+			}
+		}
+
+		if(value_state==VALUE_DELETED)
+		{
+			/* 
+			 * for deleted values, we do not want to perform a dupcheck against
+			 * existing values. Also, we do not want to add it to the
+			 * avl tree (if one is being maintained)
+			 *
+			 */
+			rc = 0; /* Presume no duplicate */
+		}
+		else if ( !check_for_duplicate_values )
+		{
+			rc = LDAP_SUCCESS;	/* presume no duplicate */
+		} else {
+			/* For value dup checking, we either use brute-force, if there's a small number */
+			/* Or a tree-based approach if there's a large number. */
+			/* The tree code is expensive, which is why we don't use it unless there's many attributes */
+			rc = 0; /* Presume no duplicate */
+			if (fast_dup_check)
+			{
+				/* Fast dup-checking */
+				/* Do we now have so many values that we should switch to tree-based checking ? */
+				if (sa->sa_present_values.num > STR2ENTRY_VALUE_DUPCHECK_THRESHOLD)
+				{
+					/* Make the tree from the existing attr values */
+					rc= valuetree_add_valuearray( sa->sa_type, sa->sa_pi, sa->sa_present_values.va, &sa->sa_vtree, NULL);
+					/* Check if the value already exists, in the tree. */
+					rc= valuetree_add_value( sa->sa_type, sa->sa_pi, value, &sa->sa_vtree);
+					fast_dup_check = 0;
+				}
+				else
+				{
+					/* JCM - need an efficient valuearray function to do this */
+					/* Brute-force check */
+					for ( j = 0; j < sa->sa_present_values.num; j++ )/* JCM innards */
+					{
+						if (0 == sa->sa_comparefn(slapi_value_get_berval(value),slapi_value_get_berval(sa->sa_present_values.va[j])))/* JCM innards */
+						{
+							/* Oops---this value matches one already present */
+							rc = LDAP_TYPE_OR_VALUE_EXISTS;
+							break;
+						}
+					}
+				}
+			}
+			else
+			{
+				/* Check if the value already exists, in the tree. */
+				rc = valuetree_add_value( sa->sa_type, sa->sa_pi, value, &sa->sa_vtree);
+			}
+		}
+
+		if ( rc==LDAP_SUCCESS )
+		{
+			if(value_state==VALUE_DELETED)
+			{
+				valuearrayfast_add_value_passin(&sa->sa_deleted_values,value);
+				value= NULL; /* value was consumed */
+			}
+			else
+			{
+				valuearrayfast_add_value_passin(&sa->sa_present_values,value);
+				value= NULL; /* value was consumed */
+			}
+			if(attributedeletioncsn!=NULL)
+			{
+				sa->sa_attributedeletioncsn= attributedeletioncsn;
+				attributedeletioncsn= NULL; /* csn was consumed */
+			}
+		}
+		else if (rc==LDAP_TYPE_OR_VALUE_EXISTS)
+		{
+		    sa->sa_numdups++;
+		}
+		else
+		{
+		    /* Failure adding to value tree */
+		    LDAPDebug( LDAP_DEBUG_ANY, "slapi_str2entry: unexpected failure %d constructing value tree\n", rc, 0, 0 );
+		    slapi_entry_free( e ); e = NULL;
+		    goto free_and_return;
+		}
+
+		slapi_value_free(&value);
+	}
+
+    /* All done with parsing.  Now create the entry. */
+    /* check to make sure there was a dn: line */
+    if ( slapi_entry_get_dn_const(e)==NULL )
+    {
+		if (!(SLAPI_STR2ENTRY_INCLUDE_VERSION_STR & flags))
+	    	LDAPDebug( LDAP_DEBUG_ANY, "slapi_str2entry: entry has no dn\n",
+									   0, 0, 0 );
+	    slapi_entry_free( e ); e = NULL;
+	    goto free_and_return;
+    }
+
+    /* get the read lock of name2asi for performance purpose.
+       It reduces read locking by per-entry lock, instead of per-attribute.
+    */
+    attr_syntax_read_lock();
+
+	/*
+	 * For each unique attribute in the array,
+	 * Create a Slapi_Attr and set it's present and deleted values.
+	 */
+    for ( i = 0; i < nattrs; i++ )
+    {
+		sa = &attrs[i];
+		if ( sa->sa_numdups > 0 )
+		{
+		    if ( sa->sa_numdups > 1 ) {
+				LDAPDebug( LDAP_DEBUG_ANY, "%d duplicate values for attribute "
+					"type %s detected in entry %s. Extra values ignored.\n",
+					sa->sa_numdups, sa->sa_type, slapi_entry_get_dn_const(e) );
+		    } else {
+				LDAPDebug( LDAP_DEBUG_ANY, "Duplicate value for attribute "
+					"type %s detected in entry %s. Extra value ignored.\n",
+					sa->sa_type, slapi_entry_get_dn_const(e), 0 );
+		    }
+		}
+		{
+			Slapi_Attr **alist= NULL;
+			if(sa->sa_state==ATTRIBUTE_DELETED)
+			{
+				if(read_stateinfo)
+				{
+					alist= &e->e_deleted_attrs;
+				}
+				else
+				{
+					/*
+					 * if we are not maintaining state info,
+					 * ignore the deleted attributes
+					 */
+				}
+			}
+			else
+			{
+				alist= &e->e_attrs;
+			}
+			if(alist!=NULL)
+			{
+				int maxvals = 0;
+				Slapi_Attr **a= NULL;
+				attrlist_find_or_create_locking_optional(alist, sa->sa_type, &a, PR_FALSE, PR_TRUE);
+				valuearray_add_valuearray_fast( /* JCM should be calling a valueset function */
+					&(*a)->a_present_values.va, /* JCM .va is private */
+					sa->sa_present_values.va,
+					0, /* Currently there are no present values on the attribute */
+					sa->sa_present_values.num,
+					&maxvals,
+					1/*Exact*/,
+					1/*Passin*/);
+				sa->sa_present_values.num= 0; /* The values have been consumed */
+				maxvals = 0;
+				valuearray_add_valuearray_fast( /* JCM should be calling a valueset function */
+					&(*a)->a_deleted_values.va, /* JCM .va is private */
+					sa->sa_deleted_values.va,
+					0, /* Currently there are no deleted values on the attribute */
+					sa->sa_deleted_values.num,
+					&maxvals,
+					1/*Exact*/,
+					1/*Passin*/);
+				sa->sa_deleted_values.num= 0; /* The values have been consumed */
+				if(sa->sa_attributedeletioncsn!=NULL)
+				{
+					attr_set_deletion_csn(*a,sa->sa_attributedeletioncsn);
+				}
+			}
+		}
+    }
+
+    /* release read lock of name2asi, per-entry lock */
+    attr_syntax_unlock_read();
+
+
+    /* Add the RDN values, if asked, and if not already present */
+    if ( flags & SLAPI_STR2ENTRY_ADDRDNVALS ) {
+        if ( slapi_entry_add_rdn_values( e ) != LDAP_SUCCESS ) {
+            LDAPDebug( LDAP_DEBUG_TRACE,
+                       "slapi_str2entry: entry has badly formatted dn\n",
+                       0, 0, 0 );
+            slapi_entry_free( e ); e = NULL;
+            goto free_and_return;
+        }
+    }
+
+	if (read_stateinfo)
+	{
+		e->e_maxcsn = maxcsn;
+	}
+
+free_and_return:
+    for ( i = 0; i < nattrs; i++ )
+    {
+		slapi_ch_free((void **) &(attrs[ i ].sa_type));
+		valuearrayfast_done(&attrs[ i ].sa_present_values);
+		valuearrayfast_done(&attrs[ i ].sa_deleted_values);
+		valuetree_free( &attrs[ i ].sa_vtree );
+    }
+	if (tree_attr_checking)
+	{
+		entry_attrs_delete(&ea);
+	}
+	slapi_ch_free((void **) &dyn_attrs );
+	if (value) slapi_value_free(&value);
+
+	LDAPDebug( LDAP_DEBUG_TRACE, "<= str2entry_dupcheck 0x%x \"%s\"\n",
+		e, slapi_sdn_get_dn (slapi_entry_get_sdn_const(e)), 0 );
+    return e;
+}
+
+/*
+ *
+ * Convert an entry in LDIF format into a
+ * Slapi_Entry structure.  If we can assume that the
+ * LDIF is well-formed we call str2entry_fast(),
+ * which does no error checking.
+ * Otherwise we do not assume well-formed LDIF, and
+ * call str2entry_dupcheck(), which checks for
+ * duplicate attribute values and does not assume
+ * that values are all contiguous.
+ * 
+ * Well-formed LDIF has the following characteristics:
+ * 1) There are no duplicate attribute values
+ * 2) The RDN is an attribute of the entry
+ * 3) All values for a given attribute type are
+ *    contiguous.
+ */
+#define SLAPI_STRENTRY_FLAGS_HANDLED_IN_SLAPI_STR2ENTRY 			\
+			( SLAPI_STR2ENTRY_IGNORE_STATE							\
+			| SLAPI_STR2ENTRY_EXPAND_OBJECTCLASSES					\
+			| SLAPI_STR2ENTRY_TOMBSTONE_CHECK						\
+			)
+
+#define SLAPI_STRENTRY_FLAGS_HANDLED_BY_STR2ENTRY_FAST				\
+ 			( SLAPI_STR2ENTRY_INCLUDE_VERSION_STR					\
+ 			| SLAPI_STRENTRY_FLAGS_HANDLED_IN_SLAPI_STR2ENTRY		\
+ 			)
+
+
+Slapi_Entry *
+slapi_str2entry( char *s, int flags )
+{
+	Slapi_Entry *e;
+	int read_stateinfo= ~( flags & SLAPI_STR2ENTRY_IGNORE_STATE );
+
+	LDAPDebug( LDAP_DEBUG_ARGS,
+			"slapi_str2entry: flags=0x%x, entry=\"%.50s...\"\n",
+			flags, s, 0 );
+
+
+	/*
+	 * If well-formed LDIF has not been provided OR if a flag that is
+	 * not handled by str2entry_fast() has been passed in, call the
+	 * slower but more forgiving str2entry_dupcheck() function.
+	 */
+	if ( 0 != ( flags & SLAPI_STR2ENTRY_NOT_WELL_FORMED_LDIF ) ||
+			0 != ( flags & ~SLAPI_STRENTRY_FLAGS_HANDLED_BY_STR2ENTRY_FAST ))
+    {
+	    e= str2entry_dupcheck( s, flags, read_stateinfo );
+    }
+    else
+    {
+	    e= str2entry_fast( s, flags, read_stateinfo );
+    }
+    if (!e)
+       return e;	/* e == NULL */
+
+	if ( flags & SLAPI_STR2ENTRY_EXPAND_OBJECTCLASSES )
+	{
+		slapi_schema_expand_objectclasses( e );
+	}
+
+    if ( flags & SLAPI_STR2ENTRY_TOMBSTONE_CHECK )
+	{
+		/*
+		 * Check if the entry is a tombstone.
+		 */
+		if(slapi_entry_attr_hasvalue(e, SLAPI_ATTR_OBJECTCLASS, SLAPI_ATTR_VALUE_TOMBSTONE))
+		{
+			e->e_flags |= SLAPI_ENTRY_FLAG_TOMBSTONE;
+		}
+	}
+	return e;
+}
+
+static size_t
+entry2str_internal_size_value( const char *attrtype, const Slapi_Value *v, int entry2str_ctrl, int attribute_state, int value_state )
+{
+	size_t elen= 0;
+	if(attrtype!=NULL)
+	{
+		size_t attrtypelen= strlen(attrtype);
+		if(entry2str_ctrl & SLAPI_DUMP_STATEINFO)
+		{
+			attrtypelen+= csnset_string_size(v->v_csnset);
+			if (attribute_state==ATTRIBUTE_DELETED)
+			{
+				attrtypelen += DELETED_ATTR_STRSIZE;
+			}
+			if(value_state==VALUE_DELETED)
+			{
+				attrtypelen += DELETED_VALUE_STRSIZE;
+			}
+		}
+		elen = LDIF_SIZE_NEEDED(attrtypelen, slapi_value_get_berval(v)->bv_len);
+	}
+	return elen;
+}
+
+static size_t
+entry2str_internal_size_valueset( const char *attrtype, const Slapi_ValueSet *vs, int entry2str_ctrl, int attribute_state, int value_state )
+{
+	size_t elen= 0;
+	if(!valueset_isempty(vs))
+	{
+		int i;
+		Slapi_Value **va= valueset_get_valuearray(vs);
+	    for (i = 0; va[i]; i++)
+	    {
+			elen+= entry2str_internal_size_value(attrtype, va[i], entry2str_ctrl,
+												 attribute_state, value_state );
+		}
+	}
+	return elen;
+}
+
+static size_t
+entry2str_internal_size_attrlist( const Slapi_Attr *attrlist, int entry2str_ctrl, int attribute_state )
+{
+	size_t elen= 0;
+	const Slapi_Attr *a;
+	for (a= attrlist; a; a = a->a_next)
+	{
+		/* skip operational attributes if not requested */
+		if ((entry2str_ctrl & SLAPI_DUMP_NOOPATTRS) &&
+			slapi_attr_flag_is_set(a, SLAPI_ATTR_FLAG_OPATTR))
+			continue;
+
+		/* Count the space required for the present and deleted values */
+		elen+= entry2str_internal_size_valueset(a->a_type, &a->a_present_values,
+												entry2str_ctrl, attribute_state,
+												VALUE_PRESENT);
+		if(entry2str_ctrl & SLAPI_DUMP_STATEINFO)
+		{
+			elen+= entry2str_internal_size_valueset(a->a_type, &a->a_deleted_values,
+													entry2str_ctrl, attribute_state,
+													VALUE_DELETED);
+			/* ";adcsn-" + a->a_deletioncsn */
+			if ( a->a_deletioncsn )
+			{
+				elen+= 1 + LDIF_CSNPREFIX_MAXLENGTH + CSN_STRSIZE;
+			}
+		}
+	}
+	return elen;
+}
+
+static void
+entry2str_internal_put_value( const char *attrtype, const CSN *attrcsn, CSNType attrcsntype, int attr_state, const Slapi_Value *v, int value_state, char **ecur, char **typebuf, size_t *typebuf_len, int entry2str_ctrl )
+{
+	const char *type;
+	unsigned long options = 0;
+        const struct berval *bvp;
+	if(entry2str_ctrl & SLAPI_DUMP_STATEINFO)
+	{
+		char *p;
+		size_t attrtypelen= strlen(attrtype);
+		size_t attrcsnlen= 0;
+		size_t valuecsnlen= 0;
+		size_t need= attrtypelen+1;
+		if(attrcsn!=NULL)
+		{
+			/* ; csntype csn */
+			attrcsnlen= 1 + csn_string_size();
+			need+= attrcsnlen;
+		}
+		if(v->v_csnset!=NULL)
+		{
+			/* +(; csntype csn) */
+			valuecsnlen= csnset_string_size(v->v_csnset);
+			need+= valuecsnlen;
+		}
+		if(attr_state==ATTRIBUTE_DELETED)
+		{
+			need+= DELETED_ATTR_STRSIZE;
+		}
+		if(value_state==VALUE_DELETED)
+		{
+			need+= DELETED_VALUE_STRSIZE; /* ;deleted */
+		}
+		if(*typebuf_len<need)
+		{
+			*typebuf= (char*)slapi_ch_realloc(*typebuf,need);
+			*typebuf_len= need;
+		}
+		p= *typebuf;
+		type= p;
+		strcpy(p,attrtype);
+		p+= attrtypelen;
+		if(attrcsn!=NULL)
+		{
+			csn_as_attr_option_string(attrcsntype,attrcsn,p);
+			p+= attrcsnlen;
+		}
+		if(v->v_csnset!=NULL)
+		{
+			csnset_as_string(v->v_csnset,p);
+			p+= valuecsnlen;
+		}
+		if(attr_state==ATTRIBUTE_DELETED)
+		{
+			strcpy(p,DELETED_ATTR_STRING);
+			p+= DELETED_ATTR_STRSIZE;
+		}
+		if(value_state==VALUE_DELETED)
+		{
+			strcpy(p,DELETED_VALUE_STRING);
+		}
+	}
+	else
+	{
+		type= attrtype;
+	}
+	if (entry2str_ctrl & SLAPI_DUMP_NOWRAP)
+		options |= LDIF_OPT_NOWRAP;
+	if (entry2str_ctrl & SLAPI_DUMP_MINIMAL_ENCODING)
+		options |= LDIF_OPT_MINIMAL_ENCODING;
+        bvp = slapi_value_get_berval(v);
+	ldif_put_type_and_value_with_options( ecur, (char*)type, bvp->bv_val, bvp->bv_len, options );
+}
+
+static void
+entry2str_internal_put_valueset( const char *attrtype, const CSN *attrcsn, CSNType attrcsntype, int attr_state, const Slapi_ValueSet *vs, int value_state, char **ecur, char **typebuf, size_t *typebuf_len, int entry2str_ctrl )
+{
+	if(!valueset_isempty(vs))
+	{
+		int i;
+		Slapi_Value **va= valueset_get_valuearray(vs);
+		for ( i = 0; va[i] != NULL; i++ )
+		{
+			/* Attach the attribute deletion csn on the first value */
+			if((entry2str_ctrl & SLAPI_DUMP_STATEINFO) && i==0)
+			{
+				entry2str_internal_put_value( attrtype, attrcsn, attrcsntype, attr_state, va[i], value_state, ecur, typebuf, typebuf_len, entry2str_ctrl );
+			}
+			else
+			{
+				entry2str_internal_put_value( attrtype, NULL, CSN_TYPE_UNKNOWN, attr_state, va[i], value_state, ecur, typebuf, typebuf_len, entry2str_ctrl );
+			}
+		}
+	}
+}
+
+static void
+entry2str_internal_put_attrlist( const Slapi_Attr *attrlist, int attr_state, int entry2str_ctrl, char **ecur, char **typebuf, size_t *typebuf_len)
+{
+	const Slapi_Attr *a;
+
+	/* Put the present attributes */
+	for (a= attrlist; a; a = a->a_next)
+	{
+		/* skip operational attributes if not requested */
+		if ((entry2str_ctrl & SLAPI_DUMP_NOOPATTRS) &&
+			slapi_attr_flag_is_set(a, SLAPI_ATTR_FLAG_OPATTR))
+			continue;
+
+		/* don't dump uniqueid if not asked */
+		if (!(strcasecmp(a->a_type, SLAPI_ATTR_UNIQUEID) == 0 &&
+			!(SLAPI_DUMP_UNIQUEID & entry2str_ctrl)))
+		{
+			/* Putting present attribute values */
+			/* put "<type>:[:] <value>" line for each value */
+			int present_values= !valueset_isempty(&a->a_present_values);
+			if(present_values)
+			{
+				entry2str_internal_put_valueset(a->a_type, a->a_deletioncsn, CSN_TYPE_ATTRIBUTE_DELETED, attr_state, &a->a_present_values, VALUE_PRESENT, ecur, typebuf, typebuf_len, entry2str_ctrl);
+			}
+			if(entry2str_ctrl & SLAPI_DUMP_STATEINFO)
+			{
+				/* Putting deleted attribute values */
+				if(present_values)
+				{
+					entry2str_internal_put_valueset(a->a_type, NULL, CSN_TYPE_NONE, attr_state, &a->a_deleted_values, VALUE_DELETED, ecur, typebuf, typebuf_len, entry2str_ctrl);
+				}
+				else
+				{
+					/* There were no present values on which to place the ADCSN, so we put it on the first deleted value. */
+					entry2str_internal_put_valueset(a->a_type, a->a_deletioncsn, CSN_TYPE_ATTRIBUTE_DELETED, attr_state, &a->a_deleted_values, VALUE_DELETED, ecur, typebuf, typebuf_len, entry2str_ctrl);
+				}
+			}
+		}
+	}
+}
+
+static char *
+entry2str_internal( Slapi_Entry *e, int *len, int entry2str_ctrl )
+{
+    char *ebuf;
+    char *ecur;
+    size_t elen = 0;
+    size_t typebuf_len= 64;
+    char *typebuf= (char *)slapi_ch_malloc(typebuf_len);
+    Slapi_Value dnvalue;
+
+    /*
+     * In string format, an entry looks like this:
+     *    dn: <dn>\n
+     *    [<attr>: <value>\n]*
+     */
+
+    ecur = ebuf = NULL;
+
+    value_init(&dnvalue,NULL,CSN_TYPE_NONE,NULL);
+
+    /* find length of buffer needed to hold this entry */
+    if (slapi_entry_get_dn_const(e)!=NULL)
+    {
+        slapi_value_set_string(&dnvalue,slapi_entry_get_dn_const(e));
+        elen+= entry2str_internal_size_value( "dn", &dnvalue, entry2str_ctrl,
+                                              ATTRIBUTE_PRESENT, VALUE_PRESENT );
+    }
+
+    /* Count the space required for the present attributes */
+    elen+= entry2str_internal_size_attrlist( e->e_attrs, entry2str_ctrl, ATTRIBUTE_PRESENT );
+
+    /* Count the space required for the deleted attributes */
+    if(entry2str_ctrl & SLAPI_DUMP_STATEINFO)
+    {
+        elen+= entry2str_internal_size_attrlist( e->e_deleted_attrs, entry2str_ctrl,
+                                                 ATTRIBUTE_DELETED );
+    }
+
+    elen += 1;
+    ecur = ebuf = (char *)slapi_ch_malloc(elen);
+
+    /* put the dn */
+    if ( slapi_entry_get_dn_const(e)!=NULL)
+    {
+        /* put "dn: <dn>" */
+        entry2str_internal_put_value("dn", NULL, CSN_TYPE_NONE, ATTRIBUTE_PRESENT, &dnvalue, VALUE_PRESENT, &ecur, &typebuf, &typebuf_len, entry2str_ctrl);
+    }
+
+    /* Put the present attributes */
+    entry2str_internal_put_attrlist( e->e_attrs, ATTRIBUTE_PRESENT, entry2str_ctrl, &ecur, &typebuf, &typebuf_len );
+
+    /* Put the deleted attributes */
+    if(entry2str_ctrl & SLAPI_DUMP_STATEINFO)
+    {
+        entry2str_internal_put_attrlist( e->e_deleted_attrs, ATTRIBUTE_DELETED, entry2str_ctrl, &ecur, &typebuf, &typebuf_len );
+    }
+    
+    *ecur = '\0';
+    if ( (size_t)(ecur - ebuf + 1) > elen )
+    {
+        slapi_log_error (SLAPI_LOG_FATAL, NULL,
+            "entry2str_internal: array boundary wrote: bufsize=%d wrote=%d\n",
+            elen, (ecur - ebuf + 1));
+    }
+
+    if ( NULL != len ) {
+        *len = ecur - ebuf;
+    }
+
+    slapi_ch_free((void**)&typebuf);
+    value_done(&dnvalue);
+    
+    return ebuf;
+}
+
+char *
+slapi_entry2str( Slapi_Entry *e, int *len )
+{
+	return entry2str_internal(e, len, 0);
+}
+
+char *
+slapi_entry2str_dump_uniqueid( Slapi_Entry *e, int *len )
+{
+	return entry2str_internal(e, len, SLAPI_DUMP_UNIQUEID);
+}
+
+char *
+slapi_entry2str_no_opattrs( Slapi_Entry *e, int *len )
+{
+	return entry2str_internal(e, len, SLAPI_DUMP_NOOPATTRS);
+}
+
+char *
+slapi_entry2str_with_options( Slapi_Entry *e, int *len, int options )
+{
+	return entry2str_internal(e, len, options);
+}
+
+static int entry_type = -1; /* The type number assigned by the Factory for 'Entry' */
+
+int
+get_entry_object_type()
+{
+    if(entry_type==-1)
+	{
+	    /* The factory is given the name of the object type, in
+		 * return for a type handle. Whenever the object is created
+		 * or destroyed the factory is called with the handle so
+		 * that it may call the constructors or destructors registered
+		 * with it.
+		 */
+        entry_type= factory_register_type(SLAPI_EXT_ENTRY,offsetof(Slapi_Entry,e_extension));
+	}
+    return entry_type;
+}
+
+/* ======  Slapi_Entry functions ====== */
+
+#ifdef ENTRY_DEBUG
+static void entry_dump( const Slapi_Entry *e, const char *text);
+#define ENTRY_DUMP(e,name) entry_dump(e,name)
+#else
+#define ENTRY_DUMP(e,name) ((void)0)
+#endif
+
+
+static int counters_created= 0;
+PR_DEFINE_COUNTER(slapi_entry_counter_created);
+PR_DEFINE_COUNTER(slapi_entry_counter_deleted);
+PR_DEFINE_COUNTER(slapi_entry_counter_exist);
+
+Slapi_Entry *
+slapi_entry_alloc()
+{
+	Slapi_Entry *e= (Slapi_Entry *) slapi_ch_calloc( 1, sizeof(struct slapi_entry) );
+	slapi_sdn_init(&e->e_sdn);
+	e->e_extension = factory_create_extension(get_entry_object_type(),e,NULL);
+	if(!counters_created)
+	{
+		PR_CREATE_COUNTER(slapi_entry_counter_created,"Slapi_Entry","created","");
+		PR_CREATE_COUNTER(slapi_entry_counter_deleted,"Slapi_Entry","deleted","");
+		PR_CREATE_COUNTER(slapi_entry_counter_exist,"Slapi_Entry","exist","");
+		counters_created= 1;
+	}
+    PR_INCREMENT_COUNTER(slapi_entry_counter_created);
+    PR_INCREMENT_COUNTER(slapi_entry_counter_exist);
+	ENTRY_DUMP(e,"slapi_entry_alloc");
+	return e;
+}
+
+/*
+ * WARNING - The DN is passed in *not* copied.
+ */
+void
+slapi_entry_init(Slapi_Entry *e, char *dn, Slapi_Attr *a)
+{
+    slapi_sdn_set_dn_passin(slapi_entry_get_sdn(e), dn);
+	e->e_uniqueid= NULL;
+    e->e_attrs= a;
+    e->e_dncsnset= NULL;
+    e->e_maxcsn= NULL;
+	e->e_deleted_attrs= NULL;
+	e->e_virtual_attrs= NULL;
+	e->e_virtual_watermark= 0;
+	e->e_virtual_lock= PR_NewRWLock(PR_RWLOCK_RANK_NONE, "vattrValueCache");
+	e->e_flags= 0;
+}
+
+void
+slapi_entry_free( Slapi_Entry *e ) /* JCM - Should be ** so that we can NULL the ptr */
+{
+	if(e!=NULL)
+	{
+		ENTRY_DUMP(e,"slapi_entry_free");
+	    factory_destroy_extension(get_entry_object_type(),e,NULL/*Parent*/,&(e->e_extension));
+	    slapi_sdn_done(&e->e_sdn);
+	    csnset_free(&e->e_dncsnset);
+	    csn_free(&e->e_maxcsn);
+		slapi_ch_free((void **)&e->e_uniqueid);
+		attrlist_free(e->e_attrs);
+		attrlist_free(e->e_deleted_attrs);
+		attrlist_free(e->e_virtual_attrs);
+		if(e->e_virtual_lock)
+            PR_DestroyRWLock(e->e_virtual_lock);
+		slapi_ch_free((void**)&e);
+	    PR_INCREMENT_COUNTER(slapi_entry_counter_deleted);
+	    PR_DECREMENT_COUNTER(slapi_entry_counter_exist);
+	}
+}
+
+static size_t slapi_attrlist_size(Slapi_Attr *attrs)
+{
+    size_t size = 0;
+    Slapi_Attr *a;
+
+    for (a= attrs; a; a = a->a_next) {
+        if (a->a_type) size += strlen(a->a_type) + 1;
+        size += valueset_size(&a->a_present_values);
+        size += valueset_size(&a->a_deleted_values);
+        /* Don't bother with a_listtofree. This is only set
+         * by a call to slapi_attr_get_values, which should
+         * never be used on a cache entry since it can cause
+         * the entry to grow without bound.
+         */
+        if (a->a_deletioncsn) size += sizeof(CSN);
+        size += sizeof(Slapi_Attr);
+    }
+
+    return size;
+}
+
+static size_t slapi_dn_size(Slapi_DN *sdn)
+{
+    size_t size = 0;
+
+    if (sdn == NULL) return 0;
+
+    if (sdn->dn) size += strlen(sdn->dn) + 1;
+    if (sdn->ndn) size *= 2;
+
+    return size;
+}
+
+/* return the approximate size of an entry --
+ * useful for checking cache sizes, etc
+ */
+size_t 
+slapi_entry_size(Slapi_Entry *e)
+{
+    u_long size = 0;
+
+    /* doesn't include memory used by e_extension */
+
+    if (e->e_uniqueid) size += strlen(e->e_uniqueid) + 1;
+    if (e->e_dncsnset) size += csnset_size(e->e_dncsnset);
+    if (e->e_maxcsn) size += sizeof( CSN );
+    size += slapi_dn_size(&e->e_sdn);
+    size += slapi_attrlist_size(e->e_attrs);
+    if (e->e_deleted_attrs) size += slapi_attrlist_size(e->e_deleted_attrs);
+    if (e->e_virtual_attrs) size += slapi_attrlist_size(e->e_virtual_attrs);
+    size += sizeof(Slapi_Entry);
+
+    return size;
+}
+
+
+/*
+ * return a complete copy of entry pointed to by "e"
+ * LPXXX: entry extensions are not duplicated
+ */
+Slapi_Entry *
+slapi_entry_dup( const Slapi_Entry *e )
+{
+	Slapi_Entry	*ec;
+	Slapi_Attr *a;
+	Slapi_Attr *lastattr= NULL;
+
+	PR_ASSERT( NULL != e );
+
+	ec = slapi_entry_alloc();
+
+	/*
+	 * init the new entry--some things (eg. locks in the entry) are not dup'ed
+	*/
+	slapi_entry_init(ec,NULL,NULL);
+
+    slapi_sdn_copy(slapi_entry_get_sdn_const(e),&ec->e_sdn);
+
+	/* duplicate the dncsn also */
+	ec->e_dncsnset= csnset_dup(e->e_dncsnset);
+	ec->e_maxcsn= csn_dup(e->e_maxcsn);
+
+	/* don't use slapi_entry_set_uniqueid here because
+       it will cause uniqueid to be added twice to the
+	   attribute list
+     */
+	if ( e->e_uniqueid != NULL )
+	{
+		ec->e_uniqueid = slapi_ch_strdup( e->e_uniqueid ); /* JCM - UniqueID Dup function? */
+	}
+
+	for ( a = e->e_attrs; a != NULL; a = a->a_next )
+	{
+		Slapi_Attr *newattr= slapi_attr_dup(a);
+		if(lastattr==NULL)
+		{
+			ec->e_attrs= newattr;
+		}
+		else
+		{
+			lastattr->a_next= newattr;
+		}
+		lastattr= newattr;
+	}
+	lastattr= NULL;
+	for ( a = e->e_deleted_attrs; a != NULL; a = a->a_next )
+	{
+		Slapi_Attr *newattr= slapi_attr_dup(a);
+		if(lastattr==NULL)
+		{
+			ec->e_deleted_attrs= newattr;
+		}
+		else
+		{
+			lastattr->a_next= newattr;
+		}
+		lastattr= newattr;
+	}
+
+	/* Copy flags as well */
+	ec->e_flags = e->e_flags;
+	
+	ENTRY_DUMP(ec,"slapi_entry_dup");
+	return( ec );
+}
+
+#ifdef ENTRY_DEBUG
+static void
+entry_dump( const Slapi_Entry *e, const char *text)
+{
+	const char *dn= slapi_entry_get_dn_const(e);
+    LDAPDebug( LDAP_DEBUG_ANY, "Entry %s ptr=%lx dn=%s\n", text, e, (dn==NULL?"NULL":dn));
+}
+#endif
+
+char *
+slapi_entry_get_dn( Slapi_Entry *e )
+{
+    /* jcm - This is evil... we have to cast away the const. */
+	return (char*)(slapi_sdn_get_dn(slapi_entry_get_sdn_const(e)));
+}
+char *
+slapi_entry_get_ndn( Slapi_Entry *e )
+{
+    /* jcm - This is evil... we have to cast away the const. */
+	return (char*)(slapi_sdn_get_ndn(slapi_entry_get_sdn_const(e)));
+}
+
+const Slapi_DN *
+slapi_entry_get_sdn_const( const Slapi_Entry *e )
+{
+    return &e->e_sdn;
+}
+
+Slapi_DN *
+slapi_entry_get_sdn( Slapi_Entry *e )
+{
+    return &e->e_sdn;
+}
+
+const char *
+slapi_entry_get_dn_const( const Slapi_Entry *e )
+{
+	return (slapi_sdn_get_dn(slapi_entry_get_sdn_const(e)));
+}
+
+/*
+ * WARNING - The DN is passed in *not* copied.
+ */
+void
+slapi_entry_set_dn( Slapi_Entry *e, char *dn )
+{
+    slapi_sdn_set_dn_passin(slapi_entry_get_sdn(e),dn);
+}
+
+void
+slapi_entry_set_sdn( Slapi_Entry *e, const Slapi_DN *sdn )
+{
+    slapi_sdn_copy(sdn,slapi_entry_get_sdn(e));
+}
+
+const char *
+slapi_entry_get_uniqueid( const Slapi_Entry *e )
+{
+	return( e->e_uniqueid );
+}
+
+/*
+ * WARNING - The UniqueID is passed in *not* copied.
+ */
+void
+slapi_entry_set_uniqueid( Slapi_Entry *e, char *uniqueid )
+{
+	e->e_uniqueid = uniqueid;
+	
+	/* also add it to the list of attributes - it makes things easier */
+	slapi_entry_attr_set_charptr ( e, SLAPI_ATTR_UNIQUEID, uniqueid );
+}
+
+int
+slapi_entry_first_attr( const Slapi_Entry *e, Slapi_Attr **a )
+{
+	return slapi_entry_next_attr( e, NULL, a);
+}
+
+int
+slapi_entry_next_attr( const Slapi_Entry *e, Slapi_Attr *prevattr, Slapi_Attr **a )
+{
+	int done= 0;
+	/*
+	 * We skip over any attributes that have no present values.
+	 * Our state information storage scheme can cause this, since
+	 * we have to hang onto the deleted value state information.
+	 * <jcm - actually we don't do this any more... so this skipping
+	 * may now be redundant.>
+	 */
+	while(!done)
+	{
+		if(prevattr==NULL)
+		{
+			*a = e->e_attrs;
+		}
+		else
+		{
+			*a = prevattr->a_next;
+		}
+		if(*a!=NULL)
+		{
+			done= !valueset_isempty(&((*a)->a_present_values));
+		}
+		else
+		{
+			done= 1;
+		}
+		if(!done)
+		{
+			prevattr= *a;
+		}
+	}
+	return( *a ? 0 : -1 );
+}
+
+int
+slapi_entry_attr_find( const Slapi_Entry *e, const char *type, Slapi_Attr **a )
+{
+	int r= -1;
+	*a = attrlist_find( e->e_attrs, type );
+	if (*a != NULL)
+	{
+		if(valueset_isempty(&((*a)->a_present_values)))
+		{
+			/*
+			 * We ignore attributes that have no present values.
+			 * Our state information storage scheme can cause this, since
+			 * we have to hang onto the deleted value state information.
+			 */
+			 *a= NULL;
+		}
+		else
+		{
+			r= 0;
+		}
+	}
+	return r;
+}
+
+/* the following functions control virtual attribute cache invalidation */
+
+static PRInt32 g_virtual_watermark = -1; /* good enough to init */
+
+int slapi_entry_vattrcache_watermark_isvalid(const Slapi_Entry *e)
+{
+	return e->e_virtual_watermark == g_virtual_watermark;
+}
+
+void slapi_entry_vattrcache_watermark_set(Slapi_Entry *e)
+{
+	e->e_virtual_watermark = g_virtual_watermark;
+}
+
+void slapi_entry_vattrcache_watermark_invalidate(Slapi_Entry *e)
+{
+	e->e_virtual_watermark = 0;
+}
+
+void slapi_entrycache_vattrcache_watermark_invalidate()
+{
+	PR_AtomicIncrement(&g_virtual_watermark);
+	if (g_virtual_watermark == 0) {
+		PR_AtomicIncrement(&g_virtual_watermark);
+	}
+}
+
+/*
+ * slapi_entry_vattrcache_findAndTest()
+ *
+ * returns: 
+ *		SLAPI_ENTRY_VATTR_NOT_RESOLVED--not found in vattrcache; *rc set to -1.
+ *		SLAPI_ENTRY_VATTR_RESOLVED_ABSENT--present in vattrcache but empty value:
+ *										means tjhat vattr type is not present in
+ *										that entry.
+ *		SLAPI_ENTRY_VATTR_RESOLVED_EXISTS--found vattr in the cache, in which
+ *										case *rc contains the result of testing
+ *										the filter f of type filter_type
+ *										on the value of type in e.
+ *										rc==-1=>not a filter match
+ *										rc==0=>a filter match
+ *										rc>0=>an LDAP error code.
+ */
+
+int
+slapi_entry_vattrcache_findAndTest( const Slapi_Entry *e, const char *type,
+								Slapi_Filter *f,
+								filter_type_t filter_type,
+								int *rc )
+{
+	Slapi_Attr *tmp_attr = NULL;
+
+	int r= SLAPI_ENTRY_VATTR_NOT_RESOLVED; /* assume not resolved yet */
+	*rc = -1;
+
+	if( slapi_vattrcache_iscacheable(type) &&
+		slapi_entry_vattrcache_watermark_isvalid(e) && e->e_virtual_attrs)
+	{
+
+		if(e->e_virtual_lock == NULL) {
+            return r;
+		}
+
+		vattrcache_entry_READ_LOCK(e);
+		tmp_attr = attrlist_find( e->e_virtual_attrs, type );
+		if (tmp_attr != NULL)
+		{
+			if(valueset_isempty(&(tmp_attr->a_present_values)))
+			{
+				/*
+				 * this is a vattr that has been
+				 * cached already but does not exist
+				 */
+				r= SLAPI_ENTRY_VATTR_RESOLVED_ABSENT; /* hard coded for prototype */				
+			}
+			else
+			{
+				/*
+				 * this is a cached vattr--test the filter on it.
+				 * 
+				*/
+				r= SLAPI_ENTRY_VATTR_RESOLVED_EXISTS;
+				if ( filter_type == FILTER_TYPE_AVA ) {
+					*rc = plugin_call_syntax_filter_ava( tmp_attr,
+														f->f_choice,
+														&f->f_ava );
+				} else if ( filter_type == FILTER_TYPE_SUBSTRING) {
+					*rc = plugin_call_syntax_filter_sub( tmp_attr,
+															&f->f_sub);
+				} else if ( filter_type == FILTER_TYPE_PRES ) {
+					/* type is there, that's all we need to know. */
+					*rc = 0;
+				}
+			}
+		}
+		vattrcache_entry_READ_UNLOCK(e);
+	}
+
+	return r;
+}
+
+/* 
+ * slapi_entry_vattrcache_find_values_and_type_ex()
+ * 
+ * returns: 
+ *		SLAPI_ENTRY_VATTR_NOT_RESOLVED--not found in vattrcache.										
+ *		SLAPI_ENTRY_VATTR_RESOLVED_ABSENT--found in vattrcache but empty value
+ *										==>that vattr type is not present in the
+ *										entry.
+ *		SLAPI_ENTRY_VATTR_RESOLVED_EXISTS--found vattr in the vattr cache,
+ *										in which case **results is a
+ *										pointer to a duped Slapi_Valueset
+ *										containing the values of type and
+ *										**actual_type_name is the actual type
+ *										name.
+*/
+
+int
+slapi_entry_vattrcache_find_values_and_type_ex( const Slapi_Entry *e,
+											const char *type,
+											Slapi_ValueSet ***results,
+											char ***actual_type_name)
+{
+	Slapi_Attr *tmp_attr = NULL;
+
+	int r= SLAPI_ENTRY_VATTR_NOT_RESOLVED; /* assume not resolved yet */
+
+	if( slapi_vattrcache_iscacheable(type) &&
+		slapi_entry_vattrcache_watermark_isvalid(e) && e->e_virtual_attrs)
+	{
+
+		if(e->e_virtual_lock == NULL) {
+            return r;
+		}
+
+		vattrcache_entry_READ_LOCK(e);
+		tmp_attr = attrlist_find( e->e_virtual_attrs, type );
+		if (tmp_attr != NULL)
+		{
+			if(valueset_isempty(&(tmp_attr->a_present_values)))
+			{
+				/*
+				 * this is a vattr that has been
+				 * cached already but does not exist
+				 */
+				r= SLAPI_ENTRY_VATTR_RESOLVED_ABSENT; /* hard coded for prototype */				
+			}
+			else
+			{
+				/*
+				 * this is a cached vattr
+				 * return a duped copy of the values and type
+				*/
+				char *vattr_type=NULL;
+
+				r= SLAPI_ENTRY_VATTR_RESOLVED_EXISTS;
+				*results = (Slapi_ValueSet**)slapi_ch_calloc(1, sizeof(*results));
+				**results = valueset_dup(&(tmp_attr->a_present_values));
+
+				*actual_type_name =
+							(char**)slapi_ch_malloc(sizeof(*actual_type_name));
+				slapi_attr_get_type( tmp_attr, &vattr_type );
+				**actual_type_name = strdup(vattr_type);
+							
+			}
+		}
+		vattrcache_entry_READ_UNLOCK(e);
+	}
+
+	return r;
+}
+
+/*
+ * Deprecated in favour of slapi_entry_vattrcache_find_values_and_type_ex()
+ * which meshes better with slapi_vattr_values_get_sp_ex().
+*/
+SLAPI_DEPRECATED int
+slapi_entry_vattrcache_find_values_and_type( const Slapi_Entry *e,
+											const char *type,
+											Slapi_ValueSet **results,
+											char **actual_type_name)
+{
+	Slapi_Attr *tmp_attr = NULL;
+
+	int r= SLAPI_ENTRY_VATTR_NOT_RESOLVED; /* assume not resolved yet */
+
+	if( slapi_vattrcache_iscacheable(type) &&
+		slapi_entry_vattrcache_watermark_isvalid(e) && e->e_virtual_attrs)
+	{
+
+		if(e->e_virtual_lock == NULL) {
+            return r;
+		}
+
+		vattrcache_entry_READ_LOCK(e);
+		tmp_attr = attrlist_find( e->e_virtual_attrs, type );
+		if (tmp_attr != NULL)
+		{
+			if(valueset_isempty(&(tmp_attr->a_present_values)))
+			{
+				/*
+				 * this is a vattr that has been
+				 * cached already but does not exist
+				 */
+				r= SLAPI_ENTRY_VATTR_RESOLVED_ABSENT; /* hard coded for prototype */				
+			}
+			else
+			{
+				/*
+				 * this is a cached vattr
+				 * return a duped copy of the values and type
+				*/
+				char *vattr_type=NULL;
+
+				r= SLAPI_ENTRY_VATTR_RESOLVED_EXISTS;
+				*results = valueset_dup(&(tmp_attr->a_present_values));
+
+				slapi_attr_get_type( tmp_attr, &vattr_type );
+				*actual_type_name = strdup(vattr_type);
+							
+			}
+		}
+		vattrcache_entry_READ_UNLOCK(e);
+	}
+
+	return r;
+}
+
+SLAPI_DEPRECATED int
+slapi_entry_attr_merge( Slapi_Entry *e, const char *type, struct berval **vals )
+{
+    Slapi_Value **values= NULL;
+    int rc=0;
+    valuearray_init_bervalarray(vals,&values); /* JCM SLOW FUNCTION */
+    rc = slapi_entry_attr_merge_sv(e, type, values);
+    valuearray_free(&values);
+    return(rc);
+}
+
+int
+slapi_entry_attr_merge_sv(Slapi_Entry *e, const char *type, Slapi_Value **vals )
+{
+    attrlist_merge_valuearray( &e->e_attrs, type, vals );
+	return 0;
+}
+
+/*
+ * Merge this valuset for type into e's vattrcache list.
+ * Creates the type if necessary.
+ * Dups valset.
+ * Only merge's in cacheable vattrs.
+*/
+
+int
+slapi_entry_vattrcache_merge_sv(Slapi_Entry *e, const char *type,
+													Slapi_ValueSet *valset)
+{
+	Slapi_Value **vals = NULL;
+
+	/* only attempt to merge if it's a cacheable attribute */
+    if ( slapi_vattrcache_iscacheable(type) ) {
+	
+		if(e->e_virtual_lock == NULL) {
+            return 0;
+		}
+	
+		vattrcache_entry_WRITE_LOCK(e);
+
+		if(!slapi_entry_vattrcache_watermark_isvalid(e) && e->e_virtual_attrs)
+		{
+			attrlist_free(e->e_virtual_attrs);
+			e->e_virtual_attrs = NULL;
+		}
+
+		if(valset)
+			vals = valueset_get_valuearray(valset);
+
+		/* dups the type (if necessary) and vals */
+	    attrlist_merge_valuearray( &e->e_virtual_attrs, type, vals);
+		slapi_entry_vattrcache_watermark_set(e);
+
+		vattrcache_entry_WRITE_UNLOCK(e);
+
+	}
+
+	return 0;
+}
+
+int
+slapi_entry_attr_delete( Slapi_Entry *e, const char *type )
+{
+    return( attrlist_delete(&e->e_attrs, type) );
+}
+
+SLAPI_DEPRECATED int
+slapi_entry_attr_replace( Slapi_Entry *e, const char *type, struct berval **vals )
+{
+    slapi_entry_attr_delete(e, type);
+    slapi_entry_attr_merge(e, type, vals);
+	return 0;
+}
+
+int
+slapi_entry_attr_replace_sv( Slapi_Entry *e, const char *type, Slapi_Value **vals )
+{
+    slapi_entry_attr_delete(e, type);
+    slapi_entry_attr_merge_sv(e, type, vals);
+	return 0;
+}
+
+int
+slapi_entry_add_value (Slapi_Entry *e, const char *type, const Slapi_Value *value)
+{
+    Slapi_Attr **a= NULL;
+    attrlist_find_or_create(&e->e_attrs, type, &a);
+    if(value != (Slapi_Value *) NULL) {
+        slapi_valueset_add_value ( &(*a)->a_present_values, value);
+    }
+    return 0;
+}
+
+
+int
+slapi_entry_add_string(Slapi_Entry *e, const char *type, const char *value)
+{
+	Slapi_Attr **a= NULL;
+	attrlist_find_or_create(&e->e_attrs, type, &a);
+	valueset_add_string ( &(*a)->a_present_values, value, CSN_TYPE_UNKNOWN, NULL);
+	return 0;
+}
+
+int
+slapi_entry_delete_string(Slapi_Entry *e, const char *type, const char *value)
+{
+	Slapi_Attr *a= attrlist_find(e->e_attrs, type);
+	if (a != NULL)
+		valueset_remove_string(a,&a->a_present_values, value);
+	return 0;
+}
+
+/* caller must free with slapi_ch_array_free */
+char **
+slapi_entry_attr_get_charray( const Slapi_Entry* e, const char *type)
+{
+    char **parray = NULL;
+    Slapi_Attr* attr = NULL;
+	slapi_entry_attr_find(e, type, &attr);
+	if(attr!=NULL)
+	{
+		int hint;
+		Slapi_Value *v = NULL;
+		for (hint = slapi_attr_first_value(attr, &v);
+			 hint != -1;
+			 hint = slapi_attr_next_value(attr, hint, &v))
+		{
+			const struct berval *bvp = slapi_value_get_berval(v);
+			char *p = slapi_ch_malloc(bvp->bv_len + 1);
+			memcpy(p, bvp->bv_val, bvp->bv_len);
+			p[bvp->bv_len]= '\0';
+			charray_add(&parray, p);
+		}
+	}
+    return parray;
+}
+
+char *
+slapi_entry_attr_get_charptr( const Slapi_Entry* e, const char *type)
+{
+    char *p= NULL;
+    Slapi_Attr* attr;
+	slapi_entry_attr_find(e, type, &attr);
+	if(attr!=NULL)
+	{
+		Slapi_Value *v;
+                const struct berval *bvp;
+		slapi_valueset_first_value( &attr->a_present_values, &v);
+                bvp = slapi_value_get_berval(v);
+        p= slapi_ch_malloc(bvp->bv_len + 1);
+        memcpy(p, bvp->bv_val, bvp->bv_len);
+        p[bvp->bv_len]= '\0';
+	}
+    return p;
+}
+
+int
+slapi_entry_attr_get_int( const Slapi_Entry* e, const char *type)
+{
+    int r= 0;
+    Slapi_Attr* attr;
+	slapi_entry_attr_find(e, type, &attr);
+    if (attr!=NULL)
+    {
+		Slapi_Value *v;
+		slapi_valueset_first_value( &attr->a_present_values, &v);
+		r= slapi_value_get_int(v);
+    }
+    return r;
+}
+
+unsigned int
+slapi_entry_attr_get_uint( const Slapi_Entry* e, const char *type)
+{
+    unsigned int r= 0;
+    Slapi_Attr* attr;
+	slapi_entry_attr_find(e, type, &attr);
+    if (attr!=NULL)
+    {
+		Slapi_Value *v;
+		slapi_valueset_first_value( &attr->a_present_values, &v);
+		r= slapi_value_get_uint(v);
+    }
+    return r;
+}
+
+long
+slapi_entry_attr_get_long( const Slapi_Entry* e, const char *type)
+{
+    long r = 0;
+    Slapi_Attr* attr;
+	slapi_entry_attr_find(e, type, &attr);
+    if (attr!=NULL)
+    {
+		Slapi_Value *v;
+		slapi_valueset_first_value( &attr->a_present_values, &v);
+		r = slapi_value_get_long(v);
+    }
+    return r;
+}
+
+unsigned long
+slapi_entry_attr_get_ulong( const Slapi_Entry* e, const char *type)
+{
+    unsigned long r = 0;
+    Slapi_Attr* attr;
+	slapi_entry_attr_find(e, type, &attr);
+    if (attr!=NULL)
+    {
+		Slapi_Value *v;
+		slapi_valueset_first_value( &attr->a_present_values, &v);
+		r = slapi_value_get_ulong(v);
+    }
+    return r;
+}
+
+void
+slapi_entry_attr_set_charptr( Slapi_Entry* e, const char *type, const char *value)
+{
+	struct berval bv;
+	struct berval *bvals[2];
+	bvals[0] = &bv;
+	bvals[1] = NULL;
+	bv.bv_val = (char*)value;
+	bv.bv_len = strlen( value );
+    slapi_entry_attr_replace( e, type, bvals );
+}
+
+void
+slapi_entry_attr_set_int( Slapi_Entry* e, const char *type, int l)
+{
+    char value[16];
+	struct berval bv;
+	struct berval *bvals[2];
+	bvals[0] = &bv;
+	bvals[1] = NULL;
+    sprintf(value,"%d",l);
+	bv.bv_val = value;
+	bv.bv_len = strlen( value );
+    slapi_entry_attr_replace( e, type, bvals );
+}
+
+void
+slapi_entry_attr_set_uint( Slapi_Entry* e, const char *type, unsigned int l)
+{
+    char value[16];
+	struct berval bv;
+	struct berval *bvals[2];
+	bvals[0] = &bv;
+	bvals[1] = NULL;
+    sprintf(value,"%u",l);
+	bv.bv_val = value;
+	bv.bv_len = strlen( value );
+    slapi_entry_attr_replace( e, type, bvals );
+}
+
+void
+slapi_entry_attr_set_long( Slapi_Entry* e, const char *type, long l)
+{
+    char value[16];
+	struct berval bv;
+	struct berval *bvals[2];
+	bvals[0] = &bv;
+	bvals[1] = NULL;
+    sprintf(value,"%ld",l);
+	bv.bv_val = value;
+	bv.bv_len = strlen( value );
+    slapi_entry_attr_replace( e, type, bvals );
+}
+
+void
+slapi_entry_attr_set_ulong( Slapi_Entry* e, const char *type, unsigned long l)
+{
+    char value[16];
+	struct berval bv;
+	struct berval *bvals[2];
+	bvals[0] = &bv;
+	bvals[1] = NULL;
+    sprintf(value,"%lu",l);
+	bv.bv_val = value;
+	bv.bv_len = strlen( value );
+    slapi_entry_attr_replace( e, type, bvals );
+}
+
+/* JCM: The strcasecmp below should really be a bervalcmp
+ * deprecatred in favour of slapi_entry_attr_has_syntax_value
+ * which does respect the syntax of the attribute type.
+*/
+
+SLAPI_DEPRECATED int
+slapi_entry_attr_hasvalue(const Slapi_Entry *e, const char *type, const char *value) /* JCM - (const char *) => (struct berval *) */
+{
+    int r= 0;
+	Slapi_Attr *attr;
+	Slapi_Value *sval;
+    if(slapi_entry_attr_find(e, type, &attr)==0)
+    {
+        int i= slapi_attr_first_value( attr, &sval );
+	    while(!r && i!=-1)
+	    {
+			const struct berval *val= slapi_value_get_berval(sval);
+            r= (strcasecmp(val->bv_val,value)==0);
+			i= slapi_attr_next_value( attr, i, &sval );
+        }
+    }
+    return r;
+}
+
+
+/*
+ * Checks if e contains an attr type with a value
+ * of value.
+ * Unlike slapi_entry_attr_hasvalue(), it does teh comparison
+ * respecting the syntax of type.
+ * 
+ * returns non-zero if type has value in e, zero otherwise.
+ *
+ *
+*/
+	
+int
+slapi_entry_attr_has_syntax_value(const Slapi_Entry *e,
+								const char *type,
+								const Slapi_Value *value)
+{
+    int r= 0;
+	Slapi_Attr *attr;
+
+    if(slapi_entry_attr_find(e, type, &attr)==0)
+    {
+		const struct berval *bv = slapi_value_get_berval(value);
+
+		if ( bv != NULL) {	
+        	r = (slapi_attr_value_find(attr, bv) == 0);
+		}
+    
+	}
+	
+    return r;			
+}
+
+
+int
+slapi_entry_rdn_values_present( const Slapi_Entry *e )
+{
+	char		**dns, **rdns;
+	int		i, rc;
+	Slapi_Attr	*attr;
+	struct ava ava;
+	const char *dn = slapi_entry_get_dn_const(e);
+
+	if (slapi_is_rootdse(dn))
+		return 1; /* the root dse has no RDN, so it should default to TRUE */
+
+	/* JCM Use the Slapi_RDN code */
+	rc = 1;
+	if ( (dns = ldap_explode_dn( slapi_entry_get_dn_const(e), 0 )) != NULL )
+	{
+		if ( (rdns = ldap_explode_rdn( dns[0], 0 )) != NULL )
+		{
+			for ( i = 0; rdns[i] != NULL; i++ )
+			{
+				if ( rdn2ava( rdns[i], &ava ) == 0 )
+				{
+					char *type = slapi_attr_syntax_normalize( ava.ava_type );
+					if ( slapi_entry_attr_find( e, type, &attr ) != 0 )
+					{
+						rc = 0;
+					}
+
+					slapi_ch_free((void **)&type);
+
+					if ( 0 == rc ) {	/* attribute not found */
+						break;
+					}
+
+					if ( slapi_attr_value_find( attr, &(ava.ava_value) ) != 0 )
+					{
+						rc = 0;
+						break;			/* value not found */
+					}
+				}
+			}
+			ldap_value_free( rdns );
+		} else {
+			rc = 0; /* Failure: the RDN seems invalid */
+		}
+		
+		ldap_value_free( dns );
+	}
+	else
+	{
+	        rc = 0; /* failure: the RDN seems to be invalid */
+	}
+
+	return( rc );
+}
+
+int
+slapi_entry_add_rdn_values( Slapi_Entry *e )
+{
+    const char *dn;
+    char	**dns, **rdns;
+    int	i, rc = LDAP_SUCCESS;
+    Slapi_Value *foundVal;
+    Slapi_Attr *attr;
+
+    if ( NULL == e || (dn = slapi_entry_get_dn_const(e))==NULL ) {
+        return( LDAP_SUCCESS );
+    }
+
+    if (slapi_is_rootdse(dn)) {
+        return( LDAP_SUCCESS );
+    }
+
+    /* JCM Use the Slapi_RDN code */
+    /* make sure RDN values are also in the entry */
+    if ( (dns = ldap_explode_dn( dn, 0 )) == NULL ) {
+        return( LDAP_INVALID_DN_SYNTAX );
+    }
+    if ( (rdns = ldap_explode_rdn( dns[0], 0 )) == NULL ) {
+        ldap_value_free( dns );
+        return( LDAP_INVALID_DN_SYNTAX );
+    }
+    ldap_value_free( dns );
+    for ( i = 0; rdns[i] != NULL && rc == LDAP_SUCCESS; i++ ) {
+        struct ava		ava;
+        char			*type;
+        
+        if ( rdn2ava( rdns[i], &ava ) != 0 ) {
+            ldap_value_free( rdns );
+            return( LDAP_INVALID_DN_SYNTAX );
+        }
+
+        foundVal = NULL;
+
+        type = slapi_attr_syntax_normalize( ava.ava_type );
+
+        if ( slapi_entry_attr_find( e, type, &attr ) == 0 ) {
+            rc = plugin_call_syntax_filter_ava_sv(attr, LDAP_FILTER_EQUALITY, 
+                                                  &ava, &foundVal, 0);
+
+            if (rc == 0 && foundVal != NULL) {
+                const struct berval *bv = slapi_value_get_berval(foundVal);
+
+                /* 
+                 * A subtlety to consider is that LDAP does not
+                 * allow two values which compare the same for
+                 * equality in an attribute at once.
+                 */
+
+                if ((ava.ava_value.bv_len != bv->bv_len) ||
+                    (memcmp(ava.ava_value.bv_val, bv->bv_val, bv->bv_len) != 0)) {
+                    /* bytes not identical so reject */
+                    char avdbuf[BUFSIZ];
+                    LDAPDebug(LDAP_DEBUG_TRACE, "RDN value is not identical to entry value for type %s in entry %s\n", 
+                               type, dn ? escape_string(dn,avdbuf) : "<null>", 0 );
+#if 0
+                    /* 
+                     * This would be the right thing to do except that
+                     * it breaks our own clients.
+                     */
+                    rc = LDAP_TYPE_OR_VALUE_EXISTS;
+#endif
+                }
+                /* exact same ava already present in entry, that's OK */
+            }
+        }
+
+        if (foundVal == NULL) {
+            struct berval *vals[2];
+
+            vals[0] = &ava.ava_value;
+            vals[1] = NULL;
+            rc = slapi_entry_add_values( e, type, vals );
+        }
+
+        slapi_ch_free( (void **)&type );
+    }
+    ldap_value_free( rdns );
+    
+    return( rc );
+}
+
+/*
+ * Function: slapi_entry_has_children
+ *
+ * Returns: 0 if "p" has no children, 1 if "p" has children.
+ *
+ * Description: We (RJP+DB) modified this code to take advantage
+ *             of the subordinatecount operational attribute that
+ *             each entry now has. 
+ *
+ * Author/Modifier: RJP
+ */
+int
+slapi_entry_has_children(const Slapi_Entry *entry)
+{
+	Slapi_Attr *attr;
+
+	LDAPDebug( LDAP_DEBUG_TRACE, "=> slapi_has_children( %s )\n", slapi_entry_get_dn_const(entry), 0, 0);
+
+	/*If the subordinatecount exists, and it's nonzero, then return 1.*/
+	if (slapi_entry_attr_find( entry, "numsubordinates", &attr) == 0)
+	{
+		Slapi_Value *sval;
+		slapi_attr_first_value( attr, &sval );
+		if(sval!=NULL)
+		{	   
+			const struct berval *bval = slapi_value_get_berval( sval );
+			if(bval!=NULL)
+			{
+				/* The entry has the attribute, and it's non-zero */
+				if (strcmp(bval->bv_val, "0") != 0)
+				{
+					LDAPDebug( LDAP_DEBUG_TRACE, "<= slapi_has_children 1\n", 0, 0, 0 );
+					return(1);
+				}
+			}
+		}
+	}
+	LDAPDebug( LDAP_DEBUG_TRACE, "<= slapi_has_children 0\n", 0, 0, 0 );
+	return(0);
+}
+
+/*
+ * Apply a set of modifications to an entry 
+ */
+int
+entry_apply_mods( Slapi_Entry *e, LDAPMod **mods )
+{
+	int	err, j;
+
+	LDAPDebug( LDAP_DEBUG_TRACE, "=> entry_apply_mods\n", 0, 0, 0 );
+
+	err = LDAP_SUCCESS;
+	for ( j = 0; mods[j] != NULL; j++ )
+	{
+		err= entry_apply_mod( e, mods[j] );
+		if ( err != LDAP_SUCCESS ) {
+			break;
+		}
+	}
+
+	LDAPDebug( LDAP_DEBUG_TRACE, "<= entry_apply_mods %d\n", err, 0, 0 );
+	return( err );
+}
+
+/*
+ * Apply a modification to an entry 
+ */
+int
+entry_apply_mod( Slapi_Entry *e, const LDAPMod *mod )
+{
+	int i;
+	int	err = LDAP_SUCCESS;
+	PRBool sawsubentry=PR_FALSE;
+
+	for ( i = 0; mod->mod_bvalues != NULL && mod->mod_bvalues[i] != NULL; i++ ) {
+	  if((strcasecmp(mod->mod_type,"objectclass") == 0)  
+              && (strncasecmp((const char *)mod->mod_bvalues[i]->bv_val,"ldapsubentry",mod->mod_bvalues[i]->bv_len) == 0)) 
+	    sawsubentry=PR_TRUE;
+	  LDAPDebug( LDAP_DEBUG_ARGS, "   %s: %s\n", mod->mod_type, mod->mod_bvalues[i]->bv_val, 0 );
+	}
+
+	switch ( mod->mod_op & ~LDAP_MOD_BVALUES )
+	{
+	case LDAP_MOD_ADD:
+		LDAPDebug( LDAP_DEBUG_ARGS, "   add: %s\n", mod->mod_type, 0, 0 );
+		if(sawsubentry) e->e_flags |= SLAPI_ENTRY_LDAPSUBENTRY;
+		err =  slapi_entry_add_values( e, mod->mod_type, mod->mod_bvalues );
+		break;
+
+	case LDAP_MOD_DELETE:
+		LDAPDebug( LDAP_DEBUG_ARGS, "   delete: %s\n", mod->mod_type, 0, 0 );
+		if(sawsubentry) e->e_flags |= 0;
+		err = slapi_entry_delete_values( e, mod->mod_type, mod->mod_bvalues );
+		break;
+
+	case LDAP_MOD_REPLACE:
+		LDAPDebug( LDAP_DEBUG_ARGS, "   replace: %s\n", mod->mod_type, 0, 0 );
+		err = entry_replace_values( e, mod->mod_type, mod->mod_bvalues );
+		break;
+	}
+	LDAPDebug( LDAP_DEBUG_ARGS, "   -\n", 0, 0, 0 );
+
+	return( err );
+}
+
+
+/*
+ * Add an array of "vals" to entry "e".
+ */
+SLAPI_DEPRECATED int
+slapi_entry_add_values(
+    Slapi_Entry		*e,
+    const char		*type,
+    struct berval	**vals
+)
+{
+    Slapi_Value **values= NULL;
+    int rc=0;
+    valuearray_init_bervalarray(vals,&values); /* JCM SLOW FUNCTION */
+    rc=slapi_entry_add_values_sv(e,type,values);
+    valuearray_free(&values);
+    return(rc);
+}
+
+/*
+ * Add an array of "vals" to entry "e".
+ */
+int
+slapi_entry_add_values_sv(Slapi_Entry *e,
+			      const char *type,
+			      Slapi_Value **vals)
+{
+	int rc= LDAP_SUCCESS;
+    if (valuearray_isempty(vals))
+	{
+		/*
+		 * No values to add (unexpected but acceptable).
+		 */
+	}
+	else
+	{
+		Slapi_Attr **a= NULL;
+		Slapi_Attr **alist= &e->e_attrs;
+		attrlist_find_or_create(alist, type, &a);
+		rc= attr_add_valuearray(*a,vals,slapi_entry_get_dn_const(e));
+    }
+    return( rc );
+}
+
+/*
+ * Add a value set of "vs" to entry "e".
+ *
+ * 0 is success anything else failure.
+ */
+
+int
+slapi_entry_add_valueset(Slapi_Entry *e, const char *type, Slapi_ValueSet *vs)
+{
+    Slapi_Value *v;
+
+    int i= slapi_valueset_first_value(vs,&v);
+    while(i!=-1) {
+
+        slapi_entry_add_value( e, type, v);
+        i= slapi_valueset_next_value(vs,i,&v);
+    }/* while */
+
+    return(0);
+}
+
+
+/*
+ * Delete an array of bervals from entry.
+ *
+ * Note that if this function fails, it leaves the values for "type" within
+ * "e" in an indeterminate state. The present value set may be truncated.
+ */
+SLAPI_DEPRECATED int
+slapi_entry_delete_values(
+    Slapi_Entry		*e,
+    const char		*type,
+    struct berval	**vals
+)
+{
+    Slapi_Value **values= NULL;
+    int rc=0;
+    valuearray_init_bervalarray(vals,&values); /* JCM SLOW FUNCTION */
+    rc=slapi_entry_delete_values_sv(e,type,values);
+    valuearray_free(&values);
+    return(rc);
+}
+
+
+static int
+delete_values_sv_internal(
+    Slapi_Entry		*e,
+    const char		*type,
+    Slapi_Value		**valuestodelete,
+	int				flags
+)
+{
+	Slapi_Attr *a;
+	int retVal= LDAP_SUCCESS;
+
+	/* delete the entire attribute */
+	if ( valuestodelete == NULL || valuestodelete[0] == NULL ){
+		LDAPDebug( LDAP_DEBUG_ARGS, "removing entire attribute %s\n",
+		    type, 0, 0 );
+		return( attrlist_delete( &e->e_attrs, type) ?
+		    LDAP_NO_SUCH_ATTRIBUTE : LDAP_SUCCESS );
+	}
+
+	/* delete specific values - find the attribute first */
+	a= attrlist_find(e->e_attrs, type);
+	if ( a == NULL ) {
+		LDAPDebug( LDAP_DEBUG_ARGS, "could not find attribute %s\n",
+		    type, 0, 0 );
+		return( LDAP_NO_SUCH_ATTRIBUTE );
+	}
+
+	{
+		retVal= valueset_remove_valuearray(&a->a_present_values, a, valuestodelete, flags, NULL);
+		if(retVal==LDAP_SUCCESS)
+		{
+			/*
+			 * all values have been deleted -- remove entire attribute
+			 */
+			if ( valueset_isempty(&a->a_present_values) )
+			{
+				attrlist_delete( &e->e_attrs, a->a_type );
+			}
+		}
+		else
+		{
+			/* Failed 
+			 * - Duplicate value
+			 * - Value not found
+			 * - Operations error
+			 */
+			if ( retVal==LDAP_OPERATIONS_ERROR )
+			{
+				LDAPDebug( LDAP_DEBUG_ANY, "Possible existing duplicate "
+					"value for attribute type %s found in "
+					"entry %s\n", a->a_type, slapi_entry_get_dn_const(e), 0 );
+			}
+		}
+	}	
+	
+	return( retVal );
+}
+
+
+/*
+ * Delete an array of present values from an entry.
+ *
+ * Note that if this function fails, it leaves the values for "type" within
+ * "e" in an indeterminate state. The present value set may be truncated.
+ */
+int
+slapi_entry_delete_values_sv(
+    Slapi_Entry		*e,
+    const char		*type,
+    Slapi_Value	**valuestodelete
+)
+{
+	return( delete_values_sv_internal( e, type, valuestodelete,
+			0 /* Do Not Ignore Errors */ ));
+}
+
+
+int
+entry_replace_values(
+    Slapi_Entry		*e,
+    const char		*type,
+    struct berval	**vals
+)
+{
+        attrlist_replace( &e->e_attrs, type, vals );
+        return 0;
+}
+
+int
+slapi_entry_flag_is_set( const Slapi_Entry *e, unsigned char flag )
+{
+	return( e->e_flags & flag );
+}
+
+void slapi_entry_set_flag( Slapi_Entry *e, unsigned char flag)
+{
+	e->e_flags |= flag;
+}
+
+void slapi_entry_clear_flag( Slapi_Entry *e, unsigned char flag)
+{
+	e->e_flags &= ~flag;
+}
+
+
+/*
+ * Add the missing values in `vals' to an entry.
+ *
+ * Note that if this function fails, it leaves the values for "type" within
+ * "e" in an indeterminate state. The present value set may be truncated.
+ */
+int
+slapi_entry_merge_values_sv(
+    Slapi_Entry		*e,
+    const char		*type,
+    Slapi_Value		**vals
+)
+{
+	int		rc;
+
+	rc = delete_values_sv_internal( e, type, vals, SLAPI_VALUE_FLAG_IGNOREERROR );
+
+	if ( rc == LDAP_SUCCESS || rc == LDAP_NO_SUCH_ATTRIBUTE ) {
+		rc = slapi_entry_attr_merge_sv( e, type, vals );
+	}
+
+	return( rc );
+}
+
+void
+send_referrals_from_entry(Slapi_PBlock *pb, Slapi_Entry *referral)
+{
+    Slapi_Value *val=NULL;
+    Slapi_Attr *attr=NULL;
+    int i=0, numValues=0;
+    struct berval **refscopy=NULL;
+    struct berval **url=NULL;
+    
+    slapi_entry_attr_find( referral, "ref", &attr );
+    if(attr != NULL) {
+        slapi_attr_get_numvalues(attr, &numValues );
+        if(numValues > 0) {
+            url=(struct berval **) slapi_ch_malloc((numValues + 1) * sizeof(struct berval*));
+        }
+        for (i = slapi_attr_first_value(attr, &val); i != -1;
+        i = slapi_attr_next_value(attr, i, &val)) {
+            url[i]=(struct berval*)slapi_value_get_berval(val);
+        }
+        url[numValues]=NULL;
+    }
+    refscopy = ref_adjust(pb, url, slapi_entry_get_sdn(referral), 0);
+    send_ldap_result(pb, LDAP_REFERRAL,
+        slapi_entry_get_dn(referral), NULL, 0, refscopy );
+    if(url != NULL) {
+        slapi_ch_free( (void **)&url );
+    }
+    if ( refscopy != NULL ) {
+       ber_bvecfree( refscopy );
+    }
+}
+
+/*
+ * slapi_entry_diff: perform diff between entry e1 and e2
+ *                   and set mods to smods which updates e1 to e2.
+ *        diff_ctrl: SLAPI_DUMP_NOOPATTRS => skip operational attributes
+ */
+void
+slapi_entry_diff(Slapi_Mods *smods, Slapi_Entry *e1, Slapi_Entry *e2, int diff_ctrl)
+{
+    Slapi_Attr *e1_attr = NULL;
+    Slapi_Attr *e2_attr = NULL;
+    char *e1_attr_name = NULL;
+    char *e2_attr_name = NULL;
+    int rval = 0;
+
+    slapi_mods_init(smods, 0);
+
+    for (slapi_entry_first_attr(e1, &e1_attr); e1_attr;
+         slapi_entry_next_attr(e1, e1_attr, &e1_attr))
+    {
+        /* skip operational attributes if not requested */
+        if ((diff_ctrl & SLAPI_DUMP_NOOPATTRS) &&
+            slapi_attr_flag_is_set(e1_attr, SLAPI_ATTR_FLAG_OPATTR))
+            continue;
+
+        slapi_attr_get_type(e1_attr, &e1_attr_name);
+        rval = slapi_entry_attr_find(e2, e1_attr_name, &e2_attr);
+        if (0 == rval)
+        {
+            int i;
+            Slapi_Value *e1_val;
+            /* attr e1_attr_names is shared with e2 */
+            /* XXX: not very efficient.
+             *      needs to be rewritten for the schema w/ lots of attributes
+             */
+            for (i = slapi_attr_first_value(e1_attr, &e1_val); i != -1;
+                 i = slapi_attr_next_value(e1_attr, i, &e1_val))
+            {
+                if (0 != slapi_attr_value_find(e2_attr,
+                                               slapi_value_get_berval(e1_val)))
+                {
+                    /* attr-value e1_val not found in e2_attr; replace it */
+                    /* XXX: does not support multi-value here */
+                    LDAPDebug(LDAP_DEBUG_TRACE,
+                        "slapi_entry_diff: attr-val of %s is not in e2; "
+                        "replace it\n",
+                        e1_attr_name, 0, 0);
+                    slapi_mods_add(smods, LDAP_MOD_REPLACE, e1_attr_name,
+                                   e1_val->bv.bv_len, e1_val->bv.bv_val);
+                }
+            }
+        }
+        else
+        {
+            /* attr e1_attr_names not found in e2 */
+            LDAPDebug(LDAP_DEBUG_TRACE,
+                      "slapi_entry_diff: attr %s is not in e2; add it\n",
+                      e1_attr_name, 0, 0);
+            slapi_mods_add_mod_values(smods, LDAP_MOD_ADD,
+                                      e1_attr_name, 
+                                      attr_get_present_values(e1_attr));
+        }
+    }
+
+    for (slapi_entry_first_attr(e2, &e2_attr); e2_attr;
+         slapi_entry_next_attr(e2, e2_attr, &e2_attr)) {
+        /* skip operational attributes if not requested */
+        if ((diff_ctrl & SLAPI_DUMP_NOOPATTRS) &&
+            slapi_attr_flag_is_set(e2_attr, SLAPI_ATTR_FLAG_OPATTR))
+            continue;
+
+        slapi_attr_get_type(e2_attr, &e2_attr_name);
+        rval = slapi_entry_attr_find(e1, e2_attr_name, &e1_attr);
+        if (0 != rval)
+        {
+            /* attr e2_attr_names not in e1 */
+            LDAPDebug(LDAP_DEBUG_TRACE,
+                      "slapi_entry_diff: attr %s is not in e1; delete it\n",
+                      e2_attr_name, 0, 0);
+            slapi_mods_add_mod_values(smods, LDAP_MOD_DELETE, e2_attr_name, NULL);
+        }
+    }
+
+    return;
+}
+
+static int
+entry_cmp_with_dn(const void *e1, const void *e2)
+{
+    return slapi_sdn_compare(slapi_entry_get_sdn_const(*(Slapi_Entry **)e1),
+                             slapi_entry_get_sdn_const(*(Slapi_Entry **)e2));
+}
+
+/* delete the entry (and sub entries if any) specified with dn */
+static void
+delete_subtree(Slapi_PBlock *pb, const char *dn, void *plg_id)
+{
+    Slapi_PBlock mypb;
+    int ret = 0;
+    int opresult;
+
+    slapi_search_internal_set_pb(pb, dn, LDAP_SCOPE_SUBTREE, "(objectclass=*)",
+        NULL, 0, NULL, NULL, plg_id, 0);
+    slapi_search_internal_pb(pb);
+
+    slapi_pblock_get(pb, SLAPI_PLUGIN_INTOP_RESULT, &ret);
+    if (ret == LDAP_SUCCESS) {
+        Slapi_Entry **entries = NULL;
+        Slapi_Entry **ep = NULL;
+        Slapi_DN *rootDN = slapi_sdn_new_dn_byval(dn);
+        slapi_pblock_get(pb, SLAPI_PLUGIN_INTOP_SEARCH_ENTRIES, &entries);
+        for (ep = entries; ep && *ep; ep++) {
+            const Slapi_DN *sdn = slapi_entry_get_sdn_const(*ep);
+            
+            if (slapi_sdn_compare(sdn, rootDN) == 0)
+                continue;
+            pblock_init(&mypb);
+            slapi_delete_internal_set_pb(&mypb, slapi_sdn_get_dn(sdn),
+                NULL, NULL, plg_id, 0);
+            slapi_delete_internal_pb(&mypb);
+            slapi_pblock_get(&mypb, SLAPI_PLUGIN_INTOP_RESULT, &opresult);
+            pblock_done(&mypb);
+        }
+        slapi_sdn_free(&rootDN);
+    }
+    pblock_done(pb);
+
+    pblock_init(pb);
+    slapi_delete_internal_set_pb(pb, dn, NULL, NULL, plg_id, 0);
+    slapi_delete_internal_pb(pb);
+    slapi_pblock_get(pb, SLAPI_PLUGIN_INTOP_RESULT, &opresult);
+    pblock_done(pb);
+}
+
+/*
+ * slapi_entries_diff: diff between entry array old_entries and curr_entries
+ *                     (testall == 0) => return immediately after the 1st diff
+ *                     (testall != 0) => scan all the entries
+ *                     (force_update == 0) => just print the diff info
+ *                     (force_update != 0) => force to go back to old
+ *                     
+ *                     return 0, if identical
+ *                     return 1, otherwise
+ */
+int
+slapi_entries_diff(Slapi_Entry **old_entries, Slapi_Entry **curr_entries,
+                   int testall, const char *logging_prestr,
+                   const int force_update, void *plg_id)
+{
+    char *my_logging_prestr = "";
+    Slapi_Entry **oep, **cep;
+    int rval = 0;
+    Slapi_PBlock pb;
+#ifdef ENTRY_DIFF_DEBUG
+    int i;
+#endif
+
+    for (oep = old_entries; oep != NULL && *oep != NULL; oep++)
+        ;
+
+    qsort(old_entries, oep - old_entries, sizeof(Slapi_Entry **),
+          entry_cmp_with_dn);
+
+#ifdef ENTRY_DIFF_DEBUG
+    LDAPDebug(LDAP_DEBUG_TRACE, "Old entries:\n", 0, 0, 0);
+    for (oep = old_entries, i = 0; oep != NULL && *oep != NULL; oep++, i++)
+    {
+        LDAPDebug(LDAP_DEBUG_TRACE, "%d: %s\n", i, slapi_entry_get_dn_const(*oep), 0);
+    }
+#endif
+
+    for (cep = curr_entries; cep != NULL && *cep != NULL; cep++)
+        ;
+
+    qsort(curr_entries, cep - curr_entries, sizeof(Slapi_Entry **),
+          entry_cmp_with_dn);
+
+#ifdef ENTRY_DIFF_DEBUG
+    LDAPDebug(LDAP_DEBUG_TRACE, "New entries:\n", 0, 0, 0);
+    for (cep = curr_entries, i = 0; cep != NULL && *cep != NULL; cep++, i++)
+    {
+        LDAPDebug(LDAP_DEBUG_TRACE, "%d: %s\n", i, slapi_entry_get_dn_const(*cep), 0);
+    }
+#endif
+
+    if (NULL != logging_prestr && '\0' != *logging_prestr)
+    {
+        my_logging_prestr = (char *)slapi_ch_malloc(strlen(logging_prestr) + 2);
+        sprintf(my_logging_prestr, "%s ", logging_prestr);
+    }
+
+    for (oep = old_entries; oep != NULL && *oep != NULL; )
+    {
+        for (cep = curr_entries; cep != NULL && *cep != NULL; )
+        {
+            int dncmp = slapi_sdn_compare(slapi_entry_get_sdn_const(*oep),
+                                          slapi_entry_get_sdn_const(*cep));
+            if (force_update)
+            {
+                pblock_init(&pb);
+            }
+
+            if (0 == dncmp)
+            {
+                Slapi_Mods *smods = slapi_mods_new();
+                LDAPMod *mod;
+                int isfirst = 1;
+
+                /* check the attr diff and do modify */
+                slapi_entry_diff(smods, *oep, *cep, SLAPI_DUMP_NOOPATTRS);
+
+                for (mod = slapi_mods_get_first_mod(smods);
+                     mod != NULL;
+                     mod = slapi_mods_get_next_mod(smods))
+                {
+                    rval = 1;
+                    if (isfirst)
+                    {
+                        LDAPDebug(LDAP_DEBUG_ANY, "%sEntry %s\n", my_logging_prestr,
+                                  slapi_entry_get_dn_const(*oep), 0);
+                        isfirst = 0;
+                    }
+
+                    switch (mod->mod_op & ~LDAP_MOD_BVALUES)
+                    {
+                    case LDAP_MOD_DELETE:
+                        LDAPDebug(LDAP_DEBUG_ANY,
+                                  "  Del Attribute %s Value %s\n",
+                                  mod->mod_type, mod->mod_bvalues?
+                                  mod->mod_bvalues[0]->bv_val:"N/A", 0);
+                        break;
+                    case LDAP_MOD_ADD:
+                        LDAPDebug(LDAP_DEBUG_ANY, 
+                                  "  Add Attribute %s Value %s\n",
+                                  mod->mod_type, mod->mod_bvalues[0]->bv_val, 0);
+                        break;
+                    case LDAP_MOD_REPLACE:
+                        LDAPDebug(LDAP_DEBUG_ANY,
+                                  "  Rep Attribute %s Value %s\n",
+                                  mod->mod_type, mod->mod_bvalues[0]->bv_val, 0);
+                        break;
+                    default:
+                        LDAPDebug(LDAP_DEBUG_ANY,
+                                  "  Unknown op %d Attribute %s\n",
+                                  mod->mod_op & ~LDAP_MOD_BVALUES,
+                                  mod->mod_type, 0);
+                        break;
+                    }
+
+                    if (!testall)
+                    {
+                        slapi_mods_free(&smods);
+                        goto out;
+                    }
+                }
+                if (0 == isfirst && force_update && testall)
+                {
+                    slapi_modify_internal_set_pb(&pb, 
+                                slapi_entry_get_dn_const(*oep),
+                                slapi_mods_get_ldapmods_byref(smods),
+                                NULL, NULL, plg_id, 0);
+
+                    slapi_modify_internal_pb(&pb);
+                }
+
+                slapi_mods_free(&smods);
+                oep++; cep++;
+            }
+            else if (dncmp > 0)    /* old_entries does not have cep */
+            {
+                rval = 1;
+                          
+                LDAPDebug(LDAP_DEBUG_ANY, "Del %sEntry %s\n", 
+                          my_logging_prestr, slapi_entry_get_dn_const(*cep), 0);
+
+                if (testall)
+                {
+                    if (force_update)
+                        delete_subtree(&pb, slapi_entry_get_dn_const(*cep), plg_id);
+                }
+                else
+                {
+                    goto out;
+                }
+                cep++;
+            }
+            else /* if (dncmp < 0)    curr_entries does not have oep */
+            {
+                rval = 1;
+                LDAPDebug(LDAP_DEBUG_ANY, "Add %sEntry %s\n", 
+                          my_logging_prestr, slapi_entry_get_dn_const(*oep), 0);
+                if (testall)
+                {
+                    if (force_update)
+                    {
+                        LDAPMod **mods;
+                        slapi_entry2mods(*oep, NULL, &mods);
+                        slapi_add_internal_set_pb(&pb, 
+                            slapi_entry_get_dn_const(*oep), mods, NULL, plg_id, 0);
+                        slapi_add_internal_pb(&pb);
+                        freepmods(mods);
+                    }
+                }
+                else
+                {
+                    goto out;
+                }
+                oep++;
+            }
+            if (force_update)
+            {
+                pblock_done(&pb);
+            }
+        }
+    }
+out:
+    if (NULL != logging_prestr && '\0' != *logging_prestr)
+        slapi_ch_free_string(&my_logging_prestr);
+
+    return rval;
+}