]> git.sur5r.net Git - openldap/blobdiff - servers/slapd/entry.c
plug leaks
[openldap] / servers / slapd / entry.c
index a6e548b934c33deb1cab963a0cd89b34d6ff51c1..c389f6b0a21f3151679e738a66694ebc2e078585 100644 (file)
@@ -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,24 @@ str2entry2( char *s, int checkvals )
                        slap_syntax_transform_func *pretty =
                                ad->ad_type->sat_syntax->ssyn_pretty;
 
-                       if( pretty ) {
+                       if ( pretty ) {
+#ifdef SLAP_ORDERED_PRETTYNORM
+                               rc = ordered_value_pretty( ad,
+                                       &vals[i], &pval, NULL );
+#else /* ! SLAP_ORDERED_PRETTYNORM */
                                rc = pretty( ad->ad_type->sat_syntax,
                                        &vals[i], &pval, NULL );
+#endif /* ! SLAP_ORDERED_PRETTYNORM */
 
-                       } else if( validate ) {
+                       } else if ( validate ) {
                                /*
                                 * validate value per syntax
                                 */
+#ifdef SLAP_ORDERED_PRETTYNORM
+                               rc = ordered_value_validate( ad, &vals[i], LDAP_MOD_ADD );
+#else /* ! SLAP_ORDERED_PRETTYNORM */
                                rc = validate( ad->ad_type->sat_syntax, &vals[i] );
+#endif /* ! SLAP_ORDERED_PRETTYNORM */
 
                        } else {
                                Debug( LDAP_DEBUG_ANY,
@@ -304,16 +312,24 @@ str2entry2( char *s, int checkvals )
                        }
                }
 
-               if( ad->ad_type->sat_equality &&
+               if ( ad->ad_type->sat_equality &&
                        ad->ad_type->sat_equality->smr_normalize )
                {
+#ifdef SLAP_ORDERED_PRETTYNORM
+                       rc = ordered_value_normalize(
+                               SLAP_MR_VALUE_OF_ATTRIBUTE_SYNTAX,
+                               ad,
+                               ad->ad_type->sat_equality,
+                               &vals[i], &nvals[i], NULL );
+#else /* ! SLAP_ORDERED_PRETTYNORM */
                        rc = ad->ad_type->sat_equality->smr_normalize(
                                SLAP_MR_VALUE_OF_ATTRIBUTE_SYNTAX,
                                ad->ad_type->sat_syntax,
                                ad->ad_type->sat_equality,
                                &vals[i], &nvals[i], NULL );
+#endif /* ! SLAP_ORDERED_PRETTYNORM */
 
-                       if( rc ) {
+                       if ( rc ) {
                                Debug( LDAP_DEBUG_ANY,
                                        "<= str2entry NULL (smr_normalize %d)\n", rc, 0, 0 );
                                goto fail;
@@ -348,7 +364,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 +396,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 +406,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 +415,7 @@ entry2str(
        *ecur = '\0';
        *len = ecur - ebuf;
 
-       return( (char *) ebuf );
+       return( ebuf );
 }
 
 void
@@ -475,24 +491,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)
@@ -570,7 +571,6 @@ void entry_partsize(Entry *e, ber_len_t *plen,
                        len += entry_lenlen(0); /* 0 nvals */
                }
        }
-       len += entry_lenlen(0); /* NUL byte at end */
        len += entry_lenlen(nat);
        len += entry_lenlen(nval);
        *plen = len;
@@ -743,11 +743,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;
                        }