silence warnings

[openldap] / servers / slapd / entry.c

diff --git a/servers/slapd/entry.c b/servers/slapd/entry.c
index f4dba0124bf4763c16a97185a6435d6e90c569bd..a494a04424360f2b0b85932c792c9fd08647091e 100644 (file)
--- a/servers/slapd/entry.c
+++ b/servers/slapd/entry.c
@@ -45,9 +45,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;
@@ -239,25 +237,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,
+                               ad->ad_type->sat_equality,
                                &vals[0], &nvals[0] );
 
                        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 +269,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 +287,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 */
@@ -543,6 +534,17 @@ int entry_encode(Entry *e, struct berval *bv)
                }
                len += entry_lenlen(i);
                siz += sizeof(struct berval);   /* empty berval at end */
+               if (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);
@@ -570,11 +572,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 +597,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).
@@ -681,37 +695,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,
-                                               "entry_decode: NULL (ssyn_normalize %d)\n",
-                                               rc, 0, 0 );
-#else
-                                       Debug( LDAP_DEBUG_ANY,
-                                               "<= entry_decode 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--;
                        }
-                       a->a_nvals[j].bv_val = NULL;
-                       a->a_nvals[j].bv_len = 0;
+                       bptr->bv_val = NULL;
+                       bptr->bv_len = 0;
+                       bptr++;
+               } else {
+                       a->a_nvals = a->a_vals;
                }
-#endif
-
        }
 
        if (a) a->a_next = NULL;