X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fentry.c;h=93c27985b3cf116155dfdac3c73c83ea02f1bfb9;hb=d1824b14ae78b128fb9ff6cf73d2ec4a0e756a90;hp=bd0274fb3964132199a8d0a33e3feabaaf060578;hpb=fcf787dc0f04f96d5c82cc607be60da33e3e6171;p=openldap

diff --git a/servers/slapd/entry.c b/servers/slapd/entry.c
index bd0274fb39..93c27985b3 100644
--- a/servers/slapd/entry.c
+++ b/servers/slapd/entry.c
@@ -2,7 +2,7 @@
 /* $OpenLDAP$ */
 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
  *
- * Copyright 1998-2005 The OpenLDAP Foundation.
+ * Copyright 1998-2006 The OpenLDAP Foundation.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -36,8 +36,8 @@
 #include "slap.h"
 #include "ldif.h"
 
-static unsigned char	*ebuf;	/* buf returned by entry2str		 */
-static unsigned char	*ecur;	/* pointer to end of currently used ebuf */
+static char		*ebuf;	/* buf returned by entry2str		 */
+static char		*ecur;	/* pointer to end of currently used ebuf */
 static int		emaxsize;/* max size of ebuf			 */
 
 /*
@@ -70,7 +70,6 @@ str2entry2( char *s, int checkvals )
 {
 	int rc;
 	Entry		*e;
-	struct berval	*nvalsp;
 	struct berval	*type, *vals, *nvals;
 	char 	*freeval;
 	AttributeDescription *ad, *ad_prev;
@@ -181,24 +180,23 @@ str2entry2( char *s, int checkvals )
 		int fv;
 
 		for (i=0; i<lines; i++) {
-			k = i;
 			for ( j=i+1; j<lines; j++ ) {
 				if ( bvmatch( type+i, type+j )) {
 					/* out of order, move intervening attributes down */
-					if ( j != k+1 ) {
-						int l;
+					if ( j != i+1 ) {
 						bv = vals[j];
 						fv = freeval[j];
-						for ( l=j; l>k; l-- ) {
-							type[l] = type[l-1];
-							vals[l] = vals[l-1];
-							freeval[l] = freeval[l-1];
+						for ( k=j; k>i; k-- ) {
+							type[k] = type[k-1];
+							vals[k] = vals[k-1];
+							freeval[k] = freeval[k-1];
 						}
-						type[l] = type[i];
-						vals[l] = bv;
-						freeval[l] = fv;
+						k++;
+						type[k] = type[i];
+						vals[k] = bv;
+						freeval[k] = fv;
 					}
-					i = k = j;
+					i++;
 				}
 			}
 		}
@@ -218,10 +216,10 @@ str2entry2( char *s, int checkvals )
 					goto fail;
 				}
 
-				rc = slap_bv2undef_ad( type+i, &ad, &text );
+				rc = slap_bv2undef_ad( type+i, &ad, &text, 0 );
 				if( rc != LDAP_SUCCESS ) {
 					Debug( LDAP_DEBUG_ANY,
-						"<= str2entry: str2undef_ad(%s): %s\n",
+						"<= str2entry: slap_str2undef_ad(%s): %s\n",
 							type[i].bv_val, text, 0 );
 					goto fail;
 				}
@@ -232,6 +230,7 @@ str2entry2( char *s, int checkvals )
 			int j, k;
 			atail->a_next = (Attribute *) ch_malloc( sizeof(Attribute) );
 			atail = atail->a_next;
+			atail->a_flags = 0;
 			atail->a_desc = ad_prev;
 			atail->a_vals = ch_malloc( (attr_cnt + 1) * sizeof(struct berval));
 			if( ad_prev->ad_type->sat_equality &&
@@ -269,15 +268,15 @@ str2entry2( char *s, int checkvals )
 			slap_syntax_transform_func *pretty =
 				ad->ad_type->sat_syntax->ssyn_pretty;
 
-			if( pretty ) {
-				rc = pretty( ad->ad_type->sat_syntax,
+			if ( pretty ) {
+				rc = ordered_value_pretty( ad,
 					&vals[i], &pval, NULL );
 
-			} else if( validate ) {
+			} else if ( validate ) {
 				/*
 			 	 * validate value per syntax
 			 	 */
-				rc = validate( ad->ad_type->sat_syntax, &vals[i] );
+				rc = ordered_value_validate( ad, &vals[i], LDAP_MOD_ADD );
 
 			} else {
 				Debug( LDAP_DEBUG_ANY,
@@ -304,16 +303,16 @@ str2entry2( char *s, int checkvals )
 			}
 		}
 
-		if( ad->ad_type->sat_equality &&
+		if ( ad->ad_type->sat_equality &&
 			ad->ad_type->sat_equality->smr_normalize )
 		{
-			rc = ad->ad_type->sat_equality->smr_normalize(
+			rc = ordered_value_normalize(
 				SLAP_MR_VALUE_OF_ATTRIBUTE_SYNTAX,
-				ad->ad_type->sat_syntax,
+				ad,
 				ad->ad_type->sat_equality,
 				&vals[i], &nvals[i], NULL );
 
-			if( rc ) {
+			if ( rc ) {
 				Debug( LDAP_DEBUG_ANY,
 			   		"<= str2entry NULL (smr_normalize %d)\n", rc, 0, 0 );
 				goto fail;
@@ -348,7 +347,7 @@ fail:
 		while ( ecur + (n) > ebuf + emaxsize ) { \
 			ptrdiff_t	offset; \
 			offset = (int) (ecur - ebuf); \
-			ebuf = (unsigned char *) ch_realloc( (char *) ebuf, \
+			ebuf = ch_realloc( ebuf, \
 				emaxsize + GRABSIZE ); \
 			emaxsize += GRABSIZE; \
 			ecur = ebuf + offset; \
@@ -380,7 +379,7 @@ entry2str(
 		/* put "dn: <dn>" */
 		tmplen = e->e_name.bv_len;
 		MAKE_SPACE( LDIF_SIZE_NEEDED( 2, tmplen ));
-		ldif_sput( (char **) &ecur, LDIF_PUT_VALUE, "dn", e->e_dn, tmplen );
+		ldif_sput( &ecur, LDIF_PUT_VALUE, "dn", e->e_dn, tmplen );
 	}
 
 	/* put the attributes */
@@ -390,7 +389,7 @@ entry2str(
 			bv = &a->a_vals[i];
 			tmplen = a->a_desc->ad_cname.bv_len;
 			MAKE_SPACE( LDIF_SIZE_NEEDED( tmplen, bv->bv_len ));
-			ldif_sput( (char **) &ecur, LDIF_PUT_VALUE,
+			ldif_sput( &ecur, LDIF_PUT_VALUE,
 				a->a_desc->ad_cname.bv_val,
 				bv->bv_val, bv->bv_len );
 		}
@@ -399,7 +398,7 @@ entry2str(
 	*ecur = '\0';
 	*len = ecur - ebuf;
 
-	return( (char *) ebuf );
+	return( ebuf );
 }
 
 void
@@ -475,24 +474,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) );
 }
 
-#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)
-{
-	if (len <= 0x7f)
-		return 1;
-	if (len <= 0xff)
-		return 2;
-	if (len <= 0xffff)
-		return 3;
-	if (len <= 0xffffff)
-		return 4;
-	return 5;
-}
-#endif
+#define entry_lenlen(l)	(((l) < 0x80) ? 1 : ((l) < 0x100) ? 2 : \
+	((l) < 0x10000) ? 3 : ((l) < 0x1000000) ? 4 : 5)
 
 static void
 entry_putlen(unsigned char **buf, ber_len_t len)
@@ -530,12 +514,12 @@ 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)
+/* Count up the sizes of the components of an entry */
+void entry_partsize(Entry *e, ber_len_t *plen,
+	int *pnattrs, int *pnvals, int norm)
 {
-	ber_len_t siz = sizeof(Entry);
 	ber_len_t len, dnlen, ndnlen;
-	int i;
+	int i, nat = 0, nval = 0;
 	Attribute *a;
 
 	dnlen = e->e_name.bv_len;
@@ -548,32 +532,45 @@ void entry_flatsize(Entry *e, ber_len_t *psiz, ber_len_t *plen, int norm)
 	}
 	for (a=e->e_attrs; a; a=a->a_next) {
 		/* For AttributeDesc, we only store the attr name */
-		siz += sizeof(Attribute);
+		nat++;
 		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);
+			nval++;
 			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 */
+		nval++;	/* 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);
+				nval++;
 				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);
+			nval++;
 		} else {
 			len += entry_lenlen(0);	/* 0 nvals */
 		}
 	}
-	len += 1;	/* NUL byte at end */
-	len += entry_lenlen(siz);
-	*psiz = siz;
+	len += entry_lenlen(nat);
+	len += entry_lenlen(nval);
 	*plen = len;
+	*pnattrs = nat;
+	*pnvals = nval;
+}
+
+/* Add up the size of the entry for a flattened buffer */
+ber_len_t entry_flatsize(Entry *e, int norm)
+{
+	ber_len_t len;
+	int nattrs, nvals;
+
+	entry_partsize(e, &len, &nattrs, &nvals, norm);
+	len += sizeof(Entry) + (nattrs * sizeof(Attribute)) +
+		(nvals * sizeof(struct berval));
+	return len;
 }
 
 /* Flatten an Entry into a buffer. The buffer is filled with just the
@@ -585,9 +582,8 @@ void entry_flatsize(Entry *e, ber_len_t *psiz, ber_len_t *plen, int norm)
  */
 int entry_encode(Entry *e, struct berval *bv)
 {
-	ber_len_t siz = sizeof(Entry);
 	ber_len_t len, dnlen, ndnlen;
-	int i;
+	int i, nattrs, nvals;
 	Attribute *a;
 	unsigned char *ptr;
 
@@ -596,12 +592,13 @@ int entry_encode(Entry *e, struct berval *bv)
 	dnlen = e->e_name.bv_len;
 	ndnlen = e->e_nname.bv_len;
 
-	entry_flatsize( e, &siz, &len, 1 );
+	entry_partsize( e, &len, &nattrs, &nvals, 1 );
 
 	bv->bv_len = len;
 	bv->bv_val = ch_malloc(len);
 	ptr = (unsigned char *)bv->bv_val;
-	entry_putlen(&ptr, siz);
+	entry_putlen(&ptr, nattrs);
+	entry_putlen(&ptr, nvals);
 	entry_putlen(&ptr, dnlen);
 	AC_MEMCPY(ptr, e->e_dn, dnlen);
 	ptr += dnlen;
@@ -619,29 +616,28 @@ int entry_encode(Entry *e, struct berval *bv)
 		*ptr++ = '\0';
 		if (a->a_vals) {
 			for (i=0; a->a_vals[i].bv_val; i++);
-			entry_putlen(&ptr, i);
-			for (i=0; a->a_vals[i].bv_val; i++) {
-			entry_putlen(&ptr, a->a_vals[i].bv_len);
-			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;
+				for (i=0; a->a_vals[i].bv_val; i++) {
+				entry_putlen(&ptr, a->a_vals[i].bv_len);
+				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';
 	return 0;
 }
 
@@ -662,7 +658,7 @@ int entry_decode(struct berval *bv, Entry **e, void *ctx)
 int entry_decode(struct berval *bv, Entry **e)
 #endif
 {
-	int i, j, count;
+	int i, j, count, nattrs, nvals;
 	int rc;
 	Attribute *a;
 	Entry *x;
@@ -671,18 +667,28 @@ int entry_decode(struct berval *bv, Entry **e)
 	unsigned char *ptr = (unsigned char *)bv->bv_val;
 	BerVarray bptr;
 
-	i = entry_getlen(&ptr);
-	if (!i) {
+	nattrs = entry_getlen(&ptr);
+	if (!nattrs) {
 		Debug( LDAP_DEBUG_ANY,
-			"entry_decode: entry length was zero\n", 0, 0, 0);
+			"entry_decode: attribute count was zero\n", 0, 0, 0);
 		return LDAP_OTHER;
 	}
+	nvals = entry_getlen(&ptr);
+	if (!nvals) {
+		Debug( LDAP_DEBUG_ANY,
+			"entry_decode: value count was zero\n", 0, 0, 0);
+		return LDAP_OTHER;
+	}
+	i = sizeof(Entry) + (nattrs * sizeof(Attribute)) +
+		(nvals * sizeof(struct berval));
 #ifdef SLAP_ZONE_ALLOC
 	x = slap_zn_calloc(1, i + bv->bv_len, ctx);
 	AC_MEMCPY((char*)x + i, bv->bv_val, bv->bv_len);
 	bv->bv_val = (char*)x + i;
 	ptr = (unsigned char *)bv->bv_val;
-	i = entry_getlen(&ptr);
+	/* pointer is reset, now advance past nattrs and nvals again */
+	entry_getlen(&ptr);
+	entry_getlen(&ptr);
 #else
 	x = ch_calloc(1, i);
 #endif
@@ -720,11 +726,11 @@ int entry_decode(struct berval *bv, Entry **e)
 		if( rc != LDAP_SUCCESS ) {
 			Debug( LDAP_DEBUG_TRACE,
 				"<= entry_decode: str2ad(%s): %s\n", ptr, text, 0 );
-			rc = slap_bv2undef_ad( &bv, &ad, &text );
+			rc = slap_bv2undef_ad( &bv, &ad, &text, 0 );
 
 			if( rc != LDAP_SUCCESS ) {
 				Debug( LDAP_DEBUG_ANY,
-					"<= entry_decode: str2undef_ad(%s): %s\n",
+					"<= entry_decode: slap_str2undef_ad(%s): %s\n",
 						ptr, text, 0 );
 				return rc;
 			}
@@ -768,6 +774,9 @@ int entry_decode(struct berval *bv, Entry **e)
 		} else {
 			a->a_nvals = a->a_vals;
 		}
+		nattrs--;
+		if ( !nattrs )
+			break;
 	}
 
 	if (a) a->a_next = NULL;