X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fentry.c;h=605247489c3e2f85561b1ee7365a92a4d01b78aa;hb=0a5f1e8516d386784ed7f605e5d03c7ee6d7cedd;hp=9884fff3fde7adcdfdf299d45ed76f194798ee09;hpb=793dada79c524c9bcdba100f67021c97366c0620;p=openldap

diff --git a/servers/slapd/entry.c b/servers/slapd/entry.c
index 9884fff3fd..605247489c 100644
--- a/servers/slapd/entry.c
+++ b/servers/slapd/entry.c
@@ -1,8 +1,27 @@
 /* entry.c - routines for dealing with entries */
 /* $OpenLDAP$ */
-/*
- * Copyright 1998-2003 The OpenLDAP Foundation, All Rights Reserved.
- * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
+/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
+ *
+ * Copyright 1998-2003 The OpenLDAP Foundation.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted only as authorized by the OpenLDAP
+ * Public License.
+ *
+ * A copy of this license is available in the file LICENSE in the
+ * top-level directory of the distribution or, alternatively, at
+ * <http://www.OpenLDAP.org/license.html>.
+ */
+/* Portions Copyright (c) 1995 Regents of the University of Michigan.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that this notice is preserved and that due credit is given
+ * to the University of Michigan at Ann Arbor. The name of the University
+ * may not be used to endorse or promote products derived from this
+ * software without specific prior written permission. This software
+ * is provided ``as is'' without express or implied warranty.
  */
 
 #include "portable.h"
@@ -45,9 +64,7 @@ str2entry( char *s )
 	Entry		*e;
 	char		*type;
 	struct berval	vals[2];
-#ifdef SLAP_NVALUES
 	struct berval	nvals[2], *nvalsp;
-#endif
 	AttributeDescription *ad;
 	const char *text;
 	char	*next;
@@ -68,9 +85,10 @@ str2entry( char *s )
 	 */
 
 #ifdef NEW_LOGGING
-	LDAP_LOG( OPERATION, DETAIL1, "str2entry: \"%s\"\n", s ? s : "NULL", 0, 0 );
+	LDAP_LOG( OPERATION, DETAIL1, "str2entry: \"%s\"\n",
+		s ? s : "NULL", 0, 0 );
 #else
-	Debug( LDAP_DEBUG_TRACE, "=> str2entry\n",
+	Debug( LDAP_DEBUG_TRACE, "=> str2entry: \"%s\"\n",
 		s ? s : "NULL", 0, 0 );
 #endif
 
@@ -129,7 +147,7 @@ str2entry( char *s )
 				return NULL;
 			}
 
-			rc = dnPrettyNormal( NULL, &vals[0], &e->e_name, &e->e_nname );
+			rc = dnPrettyNormal( NULL, &vals[0], &e->e_name, &e->e_nname, NULL );
 			if( rc != LDAP_SUCCESS ) {
 #ifdef NEW_LOGGING
 				LDAP_LOG( OPERATION, DETAIL1, 
@@ -193,7 +211,7 @@ str2entry( char *s )
 
 			if( pretty ) {
 				rc = pretty( ad->ad_type->sat_syntax,
-					&vals[0], &pval );
+					&vals[0], &pval, NULL );
 
 			} else if( validate ) {
 				/*
@@ -220,12 +238,12 @@ str2entry( char *s )
 			if( rc != 0 ) {
 #ifdef NEW_LOGGING
 				LDAP_LOG( OPERATION, ERR, 
-					"str2entry:  invalid value for syntax %s\n",
-					ad->ad_type->sat_syntax->ssyn_oid, 0, 0 );
+					"str2entry:  invalid value for attribute %s (syntax %s)\n",
+					ad->ad_cname.bv_val, ad->ad_type->sat_syntax->ssyn_oid, 0 );
 #else
 				Debug( LDAP_DEBUG_ANY,
-					"str2entry: invalid value for syntax %s\n",
-					ad->ad_type->sat_syntax->ssyn_oid, 0, 0 );
+					"str2entry: invalid value for attribute %s (syntax %s)\n",
+					ad->ad_cname.bv_val, ad->ad_type->sat_syntax->ssyn_oid, 0 );
 #endif
 				entry_free( e );
 				free( vals[0].bv_val );
@@ -239,25 +257,25 @@ str2entry( char *s )
 			}
 		}
 
-#ifdef SLAP_NVALUES
 		nvalsp = NULL;
 		nvals[0].bv_val = NULL;
 
 		if( ad->ad_type->sat_equality &&
-			ad->ad_type->sat_equality->smr_match &&
-			ad->ad_type->sat_syntax->ssyn_normalize )
+			ad->ad_type->sat_equality->smr_normalize )
 		{
-			rc = ad->ad_type->sat_syntax->ssyn_normalize(
+			rc = ad->ad_type->sat_equality->smr_normalize(
+				SLAP_MR_VALUE_OF_ATTRIBUTE_SYNTAX,
 				ad->ad_type->sat_syntax,
-				&vals[0], &nvals[0] );
+				ad->ad_type->sat_equality,
+				&vals[0], &nvals[0], NULL );
 
 			if( rc ) {
 #ifdef NEW_LOGGING
 				LDAP_LOG( OPERATION, DETAIL1,
-					"str2entry:  NULL (ssyn_normalize %d)\n" , rc, 0, 0 );
+					"str2entry:  NULL (smr_normalize %d)\n" , rc, 0, 0 );
 #else
 				Debug( LDAP_DEBUG_ANY,
-			   		"<= str2entry NULL (ssyn_normalize %d)\n", rc, 0, 0 );
+			   		"<= str2entry NULL (smr_normalize %d)\n", rc, 0, 0 );
 #endif
 
 				entry_free( e );
@@ -271,13 +289,8 @@ str2entry( char *s )
 
 			nvalsp = &nvals[0];
 		}
-#endif
 
-#ifdef SLAP_NVALUES
 		rc = attr_merge( e, ad, vals, nvalsp );
-#else
-		rc = attr_merge( e, ad, vals );
-#endif
 		if( rc != 0 ) {
 #ifdef NEW_LOGGING
 			LDAP_LOG( OPERATION, DETAIL1,
@@ -294,9 +307,7 @@ str2entry( char *s )
 
 		free( type );
 		free( vals[0].bv_val );
-#ifdef SLAP_NVALUES
 		free( nvals[0].bv_val );
-#endif
 	}
 
 	/* check to make sure there was a dn: line */
@@ -431,7 +442,7 @@ entry_free( Entry *e )
 int
 entry_cmp( Entry *e1, Entry *e2 )
 {
-	return( e1 < e2 ? -1 : (e1 > e2 ? 1 : 0) );
+	return SLAP_PTRCMP( e1, e2 );
 }
 
 int
@@ -439,9 +450,8 @@ entry_dn_cmp( const void *v_e1, const void *v_e2 )
 {
 	/* compare their normalized UPPERCASED dn's */
 	const Entry *e1 = v_e1, *e2 = v_e2;
-	int rc = e1->e_nname.bv_len - e2->e_nname.bv_len;
-	if (rc) return rc;
-	return( strcmp( e1->e_ndn, e2->e_ndn ) );
+
+	return ber_bvcmp( &e1->e_nname, &e2->e_nname );
 }
 
 int
@@ -451,8 +461,9 @@ entry_id_cmp( const void *v_e1, const void *v_e2 )
 	return( e1->e_id < e2->e_id ? -1 : (e1->e_id > e2->e_id ? 1 : 0) );
 }
 
-#ifdef SLAPD_BDB
-
+#define entry_lenlen(l)	((l) < 0x80) ? 1 : ((l) < 0x100) ? 2 : \
+	((l) < 0x10000) ? 3 : ((l) < 0x1000000) ? 4 : 5
+#if 0
 /* This is like a ber_len */
 static ber_len_t
 entry_lenlen(ber_len_t len)
@@ -467,6 +478,7 @@ entry_lenlen(ber_len_t len)
 		return 4;
 	return 5;
 }
+#endif
 
 static void
 entry_putlen(unsigned char **buf, ber_len_t len)
@@ -504,6 +516,52 @@ entry_getlen(unsigned char **buf)
 	return len;
 }
 
+/* Add up the size of the entry for a flattened buffer */
+void entry_flatsize(Entry *e, ber_len_t *psiz, ber_len_t *plen, int norm)
+{
+	ber_len_t siz = sizeof(Entry);
+	ber_len_t len, dnlen, ndnlen;
+	int i;
+	Attribute *a;
+
+	dnlen = e->e_name.bv_len;
+	len = dnlen + 1;	/* trailing NUL byte */
+	len += entry_lenlen(dnlen);
+	if (norm) {
+		ndnlen = e->e_nname.bv_len;
+		len += ndnlen + 1;
+		len += entry_lenlen(ndnlen);
+	}
+	for (a=e->e_attrs; a; a=a->a_next) {
+		/* For AttributeDesc, we only store the attr name */
+		siz += sizeof(Attribute);
+		len += a->a_desc->ad_cname.bv_len+1;
+		len += entry_lenlen(a->a_desc->ad_cname.bv_len);
+		for (i=0; a->a_vals[i].bv_val; i++) {
+			siz += sizeof(struct berval);
+			len += a->a_vals[i].bv_len + 1;
+			len += entry_lenlen(a->a_vals[i].bv_len);
+		}
+		len += entry_lenlen(i);
+		siz += sizeof(struct berval);	/* empty berval at end */
+		if (norm && a->a_nvals != a->a_vals) {
+			for (i=0; a->a_nvals[i].bv_val; i++) {
+				siz += sizeof(struct berval);
+				len += a->a_nvals[i].bv_len + 1;
+				len += entry_lenlen(a->a_nvals[i].bv_len);
+			}
+			len += entry_lenlen(i);	/* i nvals */
+			siz += sizeof(struct berval);
+		} else {
+			len += entry_lenlen(0);	/* 0 nvals */
+		}
+	}
+	len += 1;	/* NUL byte at end */
+	len += entry_lenlen(siz);
+	*psiz = siz;
+	*plen = len;
+}
+
 /* Flatten an Entry into a buffer. The buffer is filled with just the
  * strings/bervals of all the entry components. Each field is preceded
  * by its length, encoded the way ber_put_len works. Every field is NUL
@@ -528,24 +586,9 @@ int entry_encode(Entry *e, struct berval *bv)
 #endif
 	dnlen = e->e_name.bv_len;
 	ndnlen = e->e_nname.bv_len;
-	len = dnlen + ndnlen + 2;	/* two trailing NUL bytes */
-	len += entry_lenlen(dnlen);
-	len += entry_lenlen(ndnlen);
-	for (a=e->e_attrs; a; a=a->a_next) {
-		/* For AttributeDesc, we only store the attr name */
-		siz += sizeof(Attribute);
-		len += a->a_desc->ad_cname.bv_len+1;
-		len += entry_lenlen(a->a_desc->ad_cname.bv_len);
-		for (i=0; a->a_vals[i].bv_val; i++) {
-			siz += sizeof(struct berval);
-			len += a->a_vals[i].bv_len + 1;
-			len += entry_lenlen(a->a_vals[i].bv_len);
-		}
-		len += entry_lenlen(i);
-		siz += sizeof(struct berval);	/* empty berval at end */
-	}
-	len += 1;	/* NUL byte at end */
-	len += entry_lenlen(siz);
+
+	entry_flatsize( e, &siz, &len, 1 );
+
 	bv->bv_len = len;
 	bv->bv_val = ch_malloc(len);
 	ptr = (unsigned char *)bv->bv_val;
@@ -570,11 +613,23 @@ int entry_encode(Entry *e, struct berval *bv)
 		    entry_putlen(&ptr, i);
 		    for (i=0; a->a_vals[i].bv_val; i++) {
 			entry_putlen(&ptr, a->a_vals[i].bv_len);
-			memcpy(ptr, a->a_vals[i].bv_val,
+			AC_MEMCPY(ptr, a->a_vals[i].bv_val,
 				a->a_vals[i].bv_len);
 			ptr += a->a_vals[i].bv_len;
 			*ptr++ = '\0';
 		    }
+		    if (a->a_nvals != a->a_vals) {
+		    	entry_putlen(&ptr, i);
+			for (i=0; a->a_nvals[i].bv_val; i++) {
+			    entry_putlen(&ptr, a->a_nvals[i].bv_len);
+			    AC_MEMCPY(ptr, a->a_nvals[i].bv_val,
+				a->a_nvals[i].bv_len);
+			    ptr += a->a_nvals[i].bv_len;
+			    *ptr++ = '\0';
+			}
+		    } else {
+		    	entry_putlen(&ptr, 0);
+		    }
 		}
 	}
 	*ptr = '\0';
@@ -583,7 +638,7 @@ int entry_encode(Entry *e, struct berval *bv)
 
 /* Retrieve an Entry that was stored using entry_encode above.
  * We malloc a single block with the size stored above for the Entry
- * and all if its Attributes. We also must lookup the stored
+ * and all of its Attributes. We also must lookup the stored
  * attribute names to get AttributeDescriptions. To detect if the
  * attributes of an Entry are later modified, we note that e->e_attr
  * is always a constant offset from (e).
@@ -606,11 +661,11 @@ int entry_decode(struct berval *bv, Entry **e)
 	i = entry_getlen(&ptr);
 	x = ch_calloc(1, i);
 	i = entry_getlen(&ptr);
-	x->e_name.bv_val = ptr;
+	x->e_name.bv_val = (char *) ptr;
 	x->e_name.bv_len = i;
 	ptr += i+1;
 	i = entry_getlen(&ptr);
-	x->e_nname.bv_val = ptr;
+	x->e_nname.bv_val = (char *) ptr;
 	x->e_nname.bv_len = i;
 	ptr += i+1;
 #ifdef NEW_LOGGING
@@ -632,7 +687,7 @@ int entry_decode(struct berval *bv, Entry **e)
 	while ((i = entry_getlen(&ptr))) {
 		struct berval bv;
 		bv.bv_len = i;
-		bv.bv_val = ptr;
+		bv.bv_val = (char *) ptr;
 		if (a) {
 			a->a_next = (Attribute *)bptr;
 		}
@@ -681,33 +736,23 @@ int entry_decode(struct berval *bv, Entry **e)
 		bptr->bv_len = 0;
 		bptr++;
 
-#ifdef SLAP_NVALUES
-		if( count && ad->ad_type->sat_equality &&
-			ad->ad_type->sat_equality->smr_match &&
-			ad->ad_type->sat_syntax->ssyn_normalize )
-		{
-			a->a_nvals = ch_malloc((count+1)*sizeof(struct berval));
-
-			for(j=0; j<count; j++) {
-				rc = ad->ad_type->sat_syntax->ssyn_normalize(
-					ad->ad_type->sat_syntax,
-					&a->a_vals[j], &a->a_nvals[j] );
-
-				if( rc ) {
-#ifdef NEW_LOGGING
-					LDAP_LOG( OPERATION, DETAIL1,
-						"str2entry:  NULL (ssyn_normalize %d)\n" , rc, 0, 0 );
-#else
-					Debug( LDAP_DEBUG_ANY,
-				   		"<= str2entry NULL (ssyn_normalize %d)\n", rc, 0, 0 );
-#endif
-
-					return rc;
-				}
+		j = entry_getlen(&ptr);
+		if (j) {
+			a->a_nvals = bptr;
+			while (j) {
+				i = entry_getlen(&ptr);
+				bptr->bv_len = i;
+				bptr->bv_val = (char *)ptr;
+				ptr += i+1;
+				bptr++;
+				j--;
 			}
+			bptr->bv_val = NULL;
+			bptr->bv_len = 0;
+			bptr++;
+		} else {
+			a->a_nvals = a->a_vals;
 		}
-#endif
-
 	}
 
 	if (a) a->a_next = NULL;
@@ -720,4 +765,22 @@ int entry_decode(struct berval *bv, Entry **e)
 	*e = x;
 	return 0;
 }
-#endif
+
+Entry *entry_dup( Entry *e )
+{
+	Entry *ret;
+
+	ret = (Entry *)ch_calloc( 1, sizeof(*ret) );
+
+	ret->e_id = e->e_id;
+	ber_dupbv( &ret->e_name, &e->e_name );
+	ber_dupbv( &ret->e_nname, &e->e_nname );
+	ret->e_attrs = attrs_dup( e->e_attrs );
+	ret->e_ocflags = e->e_ocflags;
+	ret->e_bv.bv_val = NULL;
+	ret->e_bv.bv_len = 0;
+	ret->e_private = NULL;
+
+	return ret;
+}
+