Use IPV6_V6ONLY on IPv6 sockets if available. This way we only get IPv6

[openldap] / servers / slapd / entry.c

diff --git a/servers/slapd/entry.c b/servers/slapd/entry.c
index 08c5fd728d80f40218bee8bb88af6677ecf1aab7..f5829d395af02a3555138d88234b8df301b6e68e 100644 (file)
--- a/servers/slapd/entry.c
+++ b/servers/slapd/entry.c
@@ -1,7 +1,7 @@
 /* entry.c - routines for dealing with entries */
 /* $OpenLDAP$ */
 /*
- * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved.
+ * Copyright 1998-2002 The OpenLDAP Foundation, All Rights Reserved.
  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
  */
 
@@ -24,7 +24,7 @@ static int            emaxsize;/* max size of ebuf                     */
 /*
  * Empty root entry
  */
-const Entry slap_entry_root = { NOID, { 0, "" }, { 0, "" }, NULL, NULL };
+const Entry slap_entry_root = { NOID, { 0, "" }, { 0, "" }, NULL, 0, { 0, "" }, NULL };
 
 int entry_destroy(void)
 {
@@ -71,7 +71,7 @@ str2entry( char *s )
 #endif
 
        /* initialize reader/writer lock */
-       e = (Entry *) ch_malloc( sizeof(Entry) );
+       e = (Entry *) ch_calloc( 1, sizeof(Entry) );
 
        if( e == NULL ) {
 #ifdef NEW_LOGGING
@@ -87,12 +87,6 @@ str2entry( char *s )
 
        /* initialize entry */
        e->e_id = NOID;
-       e->e_name.bv_val = NULL;
-       e->e_name.bv_len = 0;
-       e->e_nname.bv_val = NULL;
-       e->e_nname.bv_len = 0;
-       e->e_attrs = NULL;
-       e->e_private = NULL;
 
        /* dn + attributes */
        vals[1].bv_val = NULL;
@@ -115,8 +109,6 @@ str2entry( char *s )
                }
 
                if ( strcasecmp( type, "dn" ) == 0 ) {
-                       struct berval *pdn = NULL;
-
                        free( type );
 
                        if ( e->e_dn != NULL ) {
@@ -137,22 +129,21 @@ str2entry( char *s )
                        }
 
                        rc = dnPrettyNormal( NULL, &vals[0], &e->e_name, &e->e_nname );
-                       free( vals[0].bv_val );
                        if( rc != LDAP_SUCCESS ) {
 #ifdef NEW_LOGGING
                                LDAP_LOG(( "operation", LDAP_LEVEL_DETAIL1, "str2entry: "
                                        "entry %ld has invalid DN \"%s\"\n",
-                                       (long) e->e_id,
-                                       pdn->bv_val ? pdn->bv_val : "" ));
+                                       (long) e->e_id, vals[0].bv_val ));
 #else
                                Debug( LDAP_DEBUG_ANY, "str2entry: "
                                        "entry %ld has invalid DN \"%s\"\n",
-                                       (long) e->e_id,
-                                       pdn->bv_val ? pdn->bv_val : "", 0 );
+                                       (long) e->e_id, vals[0].bv_val, 0 );
 #endif
                                entry_free( e );
+                               free( vals[0].bv_val );
                                return NULL;
                        }
+                       free( vals[0].bv_val );
                        continue;
                }
 
@@ -314,6 +305,8 @@ entry2str(
        int             i;
        ber_len_t tmplen;
 
+       assert( e != NULL );
+
        /*
         * In string format, an entry looks like this:
         *      dn: <dn>\n
@@ -369,6 +362,11 @@ entry_free( Entry *e )
                e->e_ndn = NULL;
        }
 
+       if ( e->e_bv.bv_val != NULL ) {
+               free( e->e_bv.bv_val );
+               e->e_bv.bv_val = NULL;
+       }
+
        /* free attributes */
        attrs_free( e->e_attrs );
        e->e_attrs = NULL;
@@ -511,17 +509,17 @@ int entry_encode(Entry *e, struct berval *bv)
        ptr = (unsigned char *)bv->bv_val;
        entry_putlen(&ptr, siz);
        entry_putlen(&ptr, dnlen);
-       memcpy(ptr, e->e_dn, dnlen);
+       AC_MEMCPY(ptr, e->e_dn, dnlen);
        ptr += dnlen;
        *ptr++ = '\0';
        entry_putlen(&ptr, ndnlen);
-       memcpy(ptr, e->e_ndn, ndnlen);
+       AC_MEMCPY(ptr, e->e_ndn, ndnlen);
        ptr += ndnlen;
        *ptr++ = '\0';
 
        for (a=e->e_attrs; a; a=a->a_next) {
                entry_putlen(&ptr, a->a_desc->ad_cname.bv_len);
-               memcpy(ptr, a->a_desc->ad_cname.bv_val,
+               AC_MEMCPY(ptr, a->a_desc->ad_cname.bv_val,
                        a->a_desc->ad_cname.bv_len);
                ptr += a->a_desc->ad_cname.bv_len;
                *ptr++ = '\0';
@@ -561,10 +559,10 @@ int entry_decode(struct berval *bv, Entry **e)
        const char *text;
        AttributeDescription *ad;
        unsigned char *ptr = (unsigned char *)bv->bv_val;
-       BVarray bptr;
+       BerVarray bptr;
 
        i = entry_getlen(&ptr);
-       x = ch_malloc(i);
+       x = ch_calloc(1, i);
        i = entry_getlen(&ptr);
        x->e_name.bv_val = ptr;
        x->e_name.bv_len = i;
@@ -581,17 +579,19 @@ int entry_decode(struct berval *bv, Entry **e)
            "entry_decode: \"%s\"\n",
            x->e_dn, 0, 0 );
 #endif
-       x->e_private = bv->bv_val;
+       x->e_bv = *bv;
 
        /* A valid entry must have at least one attr, so this
         * pointer can never be NULL
         */
        x->e_attrs = (Attribute *)(x+1);
-       bptr = (BVarray)x->e_attrs;
+       bptr = (BerVarray)x->e_attrs;
        a = NULL;
 
-       while (i = entry_getlen(&ptr)) {
-               struct berval bv = { i, ptr };
+       while ((i = entry_getlen(&ptr))) {
+               struct berval bv;
+               bv.bv_len = i;
+               bv.bv_val = ptr;
                if (a) {
                        a->a_next = (Attribute *)bptr;
                }
@@ -623,10 +623,10 @@ int entry_decode(struct berval *bv, Entry **e)
                }
                ptr += i + 1;
                a->a_desc = ad;
-               bptr = (BVarray)(a+1);
+               bptr = (BerVarray)(a+1);
                a->a_vals = bptr;
+               a->a_flags = 0;
                j = entry_getlen(&ptr);
-               a->a_vals[j].bv_val = NULL;
 
                while (j) {
                        i = entry_getlen(&ptr);
@@ -636,6 +636,9 @@ int entry_decode(struct berval *bv, Entry **e)
                        bptr++;
                        j--;
                }
+               bptr->bv_val = NULL;
+               bptr->bv_len = 0;
+               bptr++;
        }
        if (a)
                a->a_next = NULL;