improve memory allocation in sets

diff --git a/servers/slapd/acl.c b/servers/slapd/acl.c
index 7e939d164f9e32a031638c0881630c0b0d84102b..ca88758241078fb25162c6ddbc8a1b6186083410 100644 (file)
--- a/servers/slapd/acl.c
+++ b/servers/slapd/acl.c
@@ -1802,15 +1802,16 @@ aci_set_cb_gather( Operation *op, SlapReply *rs )
        aci_set_gather_t        *p = (aci_set_gather_t *)op->o_callback->sc_private;
        
        if ( rs->sr_type == REP_SEARCH ) {
-               BerVarray       bvals = NULL;
+               BerValue        bvals[ 2 ];
+               BerVarray       bvalsp = NULL;
                int             j;
 
                for ( j = 0; !BER_BVISNULL( &rs->sr_attrs[ j ].an_name ); j++ ) {
                        AttributeDescription    *desc = rs->sr_attrs[ j ].an_desc;
                        
                        if ( desc == slap_schema.si_ad_entryDN ) {
-                               bvals = slap_sl_malloc( sizeof( BerValue ) * 2, op->o_tmpmemctx );
-                               ber_dupbv_x( &bvals[ 0 ], &rs->sr_entry->e_nname, op->o_tmpmemctx );
+                               bvalsp = bvals;
+                               bvals[ 0 ] = rs->sr_entry->e_nname;
                                BER_BVZERO( &bvals[ 1 ] );
 
                        } else {
@@ -1823,17 +1824,14 @@ aci_set_cb_gather( Operation *op, SlapReply *rs )
                                        for ( i = 0; !BER_BVISNULL( &a->a_nvals[ i ] ); i++ )
                                                ;
 
-                                       bvals = slap_sl_malloc( sizeof( BerValue ) * ( i + 1 ), op->o_tmpmemctx );
-                                       for ( i = 0; !BER_BVISNULL( &a->a_nvals[ i ] ); i++ ) {
-                                               ber_dupbv_x( &bvals[ i ], &a->a_nvals[ i ], op->o_tmpmemctx );
-                                       }
-                                       BER_BVZERO( &bvals[ i ] );
+                                       bvalsp = a->a_nvals;
                                }
                        }
                }
 
                if ( bvals ) {
-                       p->bvals = slap_set_join( p->cookie, p->bvals, '|', bvals );
+                       p->bvals = slap_set_join( p->cookie, p->bvals,
+                                       ( '|' | SLAP_SET_RREF ), bvalsp );
                }
 
        } else {

diff --git a/servers/slapd/sets.c b/servers/slapd/sets.c
index 9fbc04afb6f7e336e4970954cc9b4a92ac946b37..4d55924bcd0c5798dc3b5b262630fb355d127084 100644 (file)
--- a/servers/slapd/sets.c
+++ b/servers/slapd/sets.c
@@ -53,33 +53,85 @@ slap_set_isempty( BerVarray set )
 }
 
 static void
-slap_set_dispose( SetCookie *cp, BerVarray set )
+slap_set_dispose( SetCookie *cp, BerVarray set, unsigned flags )
 {
-       ber_bvarray_free_x( set, cp->op->o_tmpmemctx );
+       if ( flags & SLAP_SET_REFVAL ) {
+               if ( ! ( flags & SLAP_SET_REFARR ) ) {
+                       cp->op->o_tmpfree( set, cp->op->o_tmpmemctx );
+               }
+
+       } else {
+               ber_bvarray_free_x( set, cp->op->o_tmpmemctx );
+       }
+}
+
+static BerVarray
+set_dup( SetCookie *cp, BerVarray set, unsigned flags )
+{
+       BerVarray       newset = NULL;
+
+       if ( set == NULL ) {
+               return NULL;
+       }
+
+       if ( flags & SLAP_SET_REFARR ) {
+               int     i;
+
+               for ( i = 0; !BER_BVISNULL( &set[ i ] ); i++ )
+                       ;
+               newset = cp->op->o_tmpcalloc( i + 1,
+                               sizeof(struct berval), 
+                               cp->op->o_tmpmemctx );
+               if ( newset == NULL ) {
+                       return NULL;
+               }
+
+               if ( flags & SLAP_SET_REFVAL ) {
+                       for ( i = 0; !BER_BVISNULL( &set[ i ] ); i++ ) {
+                               ber_dupbv_x( &newset[ i ], &set[ i ],
+                                               cp->op->o_tmpmemctx );
+                       }
+
+               } else {
+                       AC_MEMCPY( newset, set, ( i + 1 ) * sizeof( struct berval ) );
+               }
+               
+       } else {
+               newset = set;
+       }
+
+       return newset;
 }
 
 BerVarray
-slap_set_join( SetCookie *cp, BerVarray lset, int op, BerVarray rset )
+slap_set_join(
+       SetCookie       *cp,
+       BerVarray       lset,
+       unsigned        op_flags,
+       BerVarray       rset )
 {
        BerVarray       set;
        long            i, j, last;
+       unsigned        op = ( op_flags & SLAP_SET_OPMASK );
 
        set = NULL;
-       if ( op == '|' ) {
+       switch ( op ) {
+       case '|':
                if ( lset == NULL || BER_BVISNULL( lset ) ) {
                        if ( rset == NULL ) {
                                if ( lset == NULL ) {
-                                       return cp->op->o_tmpcalloc( 1, sizeof(struct berval),
-                                                       cp->op->o_tmpmemctx);
+                                       return cp->op->o_tmpcalloc( 1,
+                                                       sizeof(struct berval),
+                                                       cp->op->o_tmpmemctx );
                                }
-                               return lset;
+                               return set_dup( cp, lset, SLAP_SET_LREF2REF( op_flags ) );
                        }
-                       slap_set_dispose( cp, lset );
-                       return rset;
+                       slap_set_dispose( cp, lset, SLAP_SET_LREF2REF( op_flags ) );
+                       return set_dup( cp, rset, SLAP_SET_RREF2REF( op_flags ) );
                }
                if ( rset == NULL || BER_BVISNULL( rset ) ) {
-                       slap_set_dispose( cp, rset );
-                       return lset;
+                       slap_set_dispose( cp, rset, SLAP_SET_RREF2REF( op_flags ) );
+                       return set_dup( cp, lset, SLAP_SET_LREF2REF( op_flags ) );
                }
 
                i = slap_set_size( lset ) + slap_set_size( rset ) + 1;
@@ -91,35 +143,52 @@ slap_set_join( SetCookie *cp, BerVarray lset, int op, BerVarray rset )
                         * as the left-set.
                         */
                        for ( i = 0; !BER_BVISNULL( &lset[ i ] ); i++ ) {
-                               set[ i ] = lset[ i ];
+                               if ( op_flags & SLAP_SET_LREFVAL ) {
+                                       ber_dupbv_x( &set[ i ], &lset[ i ], cp->op->o_tmpmemctx );
+
+                               } else {
+                                       set[ i ] = lset[ i ];
+                               }
                        }
-                       cp->op->o_tmpfree( lset, cp->op->o_tmpmemctx );
+
                        for ( i = 0; !BER_BVISNULL( &rset[ i ] ); i++ ) {
+                               int     exists = 0;
                                for ( j = 0; !BER_BVISNULL( &set[ j ] ); j++ ) {
                                        if ( dn_match( &rset[ i ], &set[ j ] ) )
                                        {
-                                               cp->op->o_tmpfree( rset[ i ].bv_val, cp->op->o_tmpmemctx );
-                                               BER_BVZERO( &rset[ i ] );
+                                               if ( !( op_flags & SLAP_SET_RREFVAL ) ) {
+                                                       cp->op->o_tmpfree( rset[ i ].bv_val, cp->op->o_tmpmemctx );
+                                                       BER_BVZERO( &rset[ i ] );
+                                               }
+                                               exists = 1;
                                                break;          
                                        }       
                                }
-                               if ( !BER_BVISNULL( &rset[ i ] ) ) {
-                                       set[ j ] = rset[ i ];
+
+                               if ( !exists ) {
+                                       if ( op_flags & SLAP_SET_RREFVAL ) {
+                                               ber_dupbv_x( &set[ j ], &rset[ i ], cp->op->o_tmpmemctx );
+
+                                       } else {
+                                               set[ j ] = rset[ i ];
+                                       }
                                }
                        }
-                       cp->op->o_tmpfree( rset, cp->op->o_tmpmemctx );
                }
-               return set;
-       }
+               break;
 
-       if ( op == '&' ) {
+       case '&':
                if ( lset == NULL || BER_BVISNULL( lset )
                                || rset == NULL || BER_BVISNULL( rset ) )
                {
                        set = cp->op->o_tmpcalloc( 1, sizeof(struct berval),
                                        cp->op->o_tmpmemctx );
+
                } else {
-                       set = lset;
+                       set = set_dup( cp, lset, SLAP_SET_LREF2REF( op_flags ) );
+                       if ( set == NULL ) {
+                               break;
+                       }
                        lset = NULL;
                        last = slap_set_size( set ) - 1;
                        for ( i = 0; !BER_BVISNULL( &set[ i ] ); i++ ) {
@@ -128,6 +197,7 @@ slap_set_join( SetCookie *cp, BerVarray lset, int op, BerVarray rset )
                                                break;
                                        }
                                }
+
                                if ( BER_BVISNULL( &rset[ j ] ) ) {
                                        cp->op->o_tmpfree( set[ i ].bv_val, cp->op->o_tmpmemctx );
                                        set[ i ] = set[ last ];
@@ -137,10 +207,20 @@ slap_set_join( SetCookie *cp, BerVarray lset, int op, BerVarray rset )
                                }
                        }
                }
+               break;
+
+       default:
+               break;
+       }
+
+       if ( !( op_flags & SLAP_SET_LREFARR ) && lset != NULL ) {
+               cp->op->o_tmpfree( lset, cp->op->o_tmpmemctx );
+       }
+
+       if ( !( op_flags & SLAP_SET_RREFARR ) && rset != NULL ) {
+               cp->op->o_tmpfree( rset, cp->op->o_tmpmemctx );
        }
 
-       slap_set_dispose( cp, lset );
-       slap_set_dispose( cp, rset );
        return set;
 }
 
@@ -160,7 +240,7 @@ set_chase( SLAP_SET_GATHER gatherer,
 
        nset = cp->op->o_tmpcalloc( 1, sizeof(struct berval), cp->op->o_tmpmemctx );
        if ( nset == NULL ) {
-               slap_set_dispose( cp, set );
+               slap_set_dispose( cp, set, 0 );
                return NULL;
        }
        for ( i = 0; !BER_BVISNULL( &set[ i ] ); i++ ) {
@@ -169,7 +249,7 @@ set_chase( SLAP_SET_GATHER gatherer,
                        nset = slap_set_join( cp, nset, '|', vals );
                }
        }
-       slap_set_dispose( cp, set );
+       slap_set_dispose( cp, set, 0 );
 
        if ( closure ) {
                for ( i = 0; !BER_BVISNULL( &nset[ i ] ); i++ ) {
@@ -203,7 +283,8 @@ slap_set_filter( SLAP_SET_GATHER gatherer,
 
        BerVarray       set, lset;
        BerVarray       stack[64] = { 0 };
-       int             len, op, rc, stp;
+       int             len, rc, stp;
+       unsigned        op;
        char            c, *filter = fbv->bv_val;
 
        if ( results ) {
@@ -238,7 +319,7 @@ slap_set_filter( SLAP_SET_GATHER gatherer,
                                set = NULL;
 
                        } else if ( IS_OP( SF_TOP() ) ) {
-                               op = (long)SF_POP();
+                               op = (unsigned)SF_POP();
                                lset = SF_POP();
                                SF_POP();
                                set = slap_set_join( cp, lset, op, set );
@@ -264,7 +345,7 @@ slap_set_filter( SLAP_SET_GATHER gatherer,
                                set = NULL;
 
                        } else if ( IS_OP( SF_TOP() ) ) {
-                               op = (long)SF_POP();
+                               op = (unsigned)SF_POP();
                                lset = SF_POP();
                                set = slap_set_join( cp, lset, op, set );
                                if ( set == NULL ) {
@@ -410,7 +491,7 @@ slap_set_filter( SLAP_SET_GATHER gatherer,
                /* FIXME: ok ? */ ;
 
        } else if ( IS_OP( SF_TOP() ) ) {
-               op = (long)SF_POP();
+               op = (unsigned)SF_POP();
                lset = SF_POP();
                set = slap_set_join( cp, lset, op, set );
                if ( set == NULL ) {
@@ -429,11 +510,11 @@ slap_set_filter( SLAP_SET_GATHER gatherer,
 
 _error:
        if ( IS_SET( set ) ) {
-               slap_set_dispose( cp, set );
+               slap_set_dispose( cp, set, 0 );
        }
        while ( ( set = SF_POP() ) ) {
                if ( IS_SET( set ) ) {
-                       slap_set_dispose( cp, set );
+                       slap_set_dispose( cp, set, 0 );
                }
        }
        return rc;

diff --git a/servers/slapd/sets.h b/servers/slapd/sets.h
index 7346e12d80b77f0e2ecee425c0277159db803e65..bc5ea7155d6d15ecd0b1fff8685acf8ad9a3d126 100644 (file)
--- a/servers/slapd/sets.h
+++ b/servers/slapd/sets.h
@@ -38,7 +38,37 @@ LDAP_SLAPD_F (int) slap_set_filter(
        struct berval *user, struct berval *target, BerVarray *results);
 
 LDAP_SLAPD_F (BerVarray) slap_set_join(SetCookie *cp,
-       BerVarray lset, int op, BerVarray rset);
+       BerVarray lset, unsigned op, BerVarray rset);
+
+#define SLAP_SET_OPMASK                0x00FF
+
+#define SLAP_SET_REFARR                0x0100
+#define SLAP_SET_REFVAL                0x0200
+#define SLAP_SET_REF           (SLAP_SET_REFARR|SLAP_SET_REFVAL)
+
+/* The unsigned "op" can be ORed with the flags below;
+ * - if the rset's values must not be freed, or must be copied if kept,
+ *   it is ORed with SLAP_SET_RREFVAL
+ * - if the rset array must not be freed, or must be copied if kept,
+ *   it is ORed with SLAP_SET_RREFARR
+ * - the same applies to the lset with SLAP_SET_LREFVAL and SLAP_SET_LREFARR
+ * - it is assumed that SLAP_SET_REFVAL implies SLAP_SET_REFARR,
+ *   i.e. the former is checked only if the latter is defined.
+ */
+
+#define SLAP_SET_RREFARR       SLAP_SET_REFARR
+#define SLAP_SET_RREFVAL       SLAP_SET_REFVAL
+#define SLAP_SET_RREF          SLAP_SET_REF
+#define SLAP_SET_RREFMASK      0x0F00
+
+#define SLAP_SET_RREF2REF(r)   ((r) & SLAP_SET_RREFMASK)
+       
+#define SLAP_SET_LREFARR       0x1000
+#define SLAP_SET_LREFVAL       0x2000
+#define SLAP_SET_LREF          (SLAP_SET_LREFARR|SLAP_SET_LREFVAL)
+#define SLAP_SET_LREFMASK      0xF000
+       
+#define SLAP_SET_LREF2REF(r)   (((r) & SLAP_SET_LREFMASK) >> 4)
        
 LDAP_END_DECL