]> git.sur5r.net Git - openldap/blobdiff - servers/slapd/back-ldbm/compare.c
limit checking in syncrepl
[openldap] / servers / slapd / back-ldbm / compare.c
index dad8445069c63e3f58148938b72f6611579c4865..43465aacf3a2a6cb0b3eba1fd6425fa8aa99de38 100644 (file)
@@ -1,8 +1,17 @@
 /* compare.c - ldbm backend compare routine */
 /* $OpenLDAP$ */
-/*
- * Copyright 1998-2003 The OpenLDAP Foundation, All Rights Reserved.
- * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
+/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
+ *
+ * Copyright 1998-2004 The OpenLDAP Foundation.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted only as authorized by the OpenLDAP
+ * Public License.
+ *
+ * A copy of this license is available in the file LICENSE in the
+ * top-level directory of the distribution or, alternatively, at
+ * <http://www.OpenLDAP.org/license.html>.
  */
 
 #include "portable.h"
 
 int
 ldbm_back_compare(
-    Backend    *be,
-    Connection *conn,
-    Operation  *op,
-    struct berval      *dn,
-    struct berval      *ndn,
-       AttributeAssertion *ava
-)
+       Operation       *op,
+       SlapReply       *rs )
 {
-       struct ldbminfo *li = (struct ldbminfo *) be->be_private;
+       struct ldbminfo *li = (struct ldbminfo *) op->o_bd->be_private;
        Entry           *matched;
        Entry           *e;
        Attribute       *a;
-       int             rc;
        int             manageDSAit = get_manageDSAit( op );
 
        /* grab giant lock for reading */
        ldap_pvt_thread_rdwr_rlock(&li->li_giant_rwlock);
 
        /* get entry with reader lock */
-       if ( (e = dn2entry_r( be, ndn, &matched )) == NULL ) {
-               char *matched_dn = NULL;
-               BerVarray refs = NULL;
-
+       if ( (e = dn2entry_r( op->o_bd, &op->o_req_ndn, &matched )) == NULL ) {
                if ( matched != NULL ) {
-                       matched_dn = ch_strdup( matched->e_dn );
-                       refs = is_entry_referral( matched )
-                               ? get_entry_referrals( be, conn, op, matched )
+                       rs->sr_matched = ch_strdup( matched->e_dn );
+                       rs->sr_ref = is_entry_referral( matched )
+                               ? get_entry_referrals( op, matched )
                                : NULL;
                        cache_return_entry_r( &li->li_cache, matched );
                } else {
-                       refs = referral_rewrite( default_referral,
-                               NULL, dn, LDAP_SCOPE_DEFAULT );
+                       rs->sr_ref = referral_rewrite( default_referral,
+                               NULL, &op->o_req_dn, LDAP_SCOPE_DEFAULT );
                }
 
                ldap_pvt_thread_rdwr_runlock(&li->li_giant_rwlock);
 
-               send_ldap_result( conn, op, LDAP_REFERRAL,
-                       matched_dn, NULL, refs, NULL );
-
-               if ( refs ) ber_bvarray_free( refs );
-               free( matched_dn );
+               rs->sr_err = LDAP_REFERRAL;
+               send_ldap_result( op, rs );
 
+               if ( rs->sr_ref ) ber_bvarray_free( rs->sr_ref );
+               free( (char *)rs->sr_matched );
+               rs->sr_ref = NULL;
+               rs->sr_matched = NULL;
                return( 1 );
        }
 
        if (!manageDSAit && is_entry_referral( e ) ) {
                /* entry is a referral, don't allow add */
-               BerVarray refs = get_entry_referrals( be,
-                       conn, op, e );
+               rs->sr_ref = get_entry_referrals( op, e );
 
 #ifdef NEW_LOGGING
                LDAP_LOG( BACK_LDBM, INFO, 
@@ -77,57 +77,54 @@ ldbm_back_compare(
 #endif
 
 
-               send_ldap_result( conn, op, LDAP_REFERRAL,
-                   e->e_dn, NULL, refs, NULL );
-
-               if (refs ) ber_bvarray_free( refs );
+               rs->sr_err = LDAP_REFERRAL;
+               rs->sr_matched = e->e_name.bv_val;
+               send_ldap_result( op, rs );
 
-               rc = 1;
+               if ( rs->sr_ref ) ber_bvarray_free( rs->sr_ref );
+               rs->sr_ref = NULL;
+               rs->sr_matched = NULL;
+               rs->sr_err = 1;
                goto return_results;
        }
 
-       if ( ! access_allowed( be, conn, op, e,
-               ava->aa_desc, &ava->aa_value, ACL_COMPARE, NULL ) )
+       if ( ! access_allowed( op, e,
+               op->oq_compare.rs_ava->aa_desc, &op->oq_compare.rs_ava->aa_value, ACL_COMPARE, NULL ) )
        {
-               send_ldap_result( conn, op, LDAP_INSUFFICIENT_ACCESS,
-                       NULL, NULL, NULL, NULL );
-               rc = 1;
+               send_ldap_error( op, rs, LDAP_INSUFFICIENT_ACCESS,
+                       NULL );
+               rs->sr_err = 1;
                goto return_results;
        }
 
-       rc = LDAP_NO_SUCH_ATTRIBUTE;
+       rs->sr_err = LDAP_NO_SUCH_ATTRIBUTE;
 
-       for(a = attrs_find( e->e_attrs, ava->aa_desc );
+       for(a = attrs_find( e->e_attrs, op->oq_compare.rs_ava->aa_desc );
                a != NULL;
-               a = attrs_find( a->a_next, ava->aa_desc ))
+               a = attrs_find( a->a_next, op->oq_compare.rs_ava->aa_desc ))
        {
-               rc = LDAP_COMPARE_FALSE;
+               rs->sr_err = LDAP_COMPARE_FALSE;
 
-#ifdef SLAP_NVALUES
-               if ( value_find_ex( ava->aa_desc,
+               if ( value_find_ex( op->oq_compare.rs_ava->aa_desc,
                        SLAP_MR_ATTRIBUTE_VALUE_NORMALIZED_MATCH |
                                SLAP_MR_ASSERTED_VALUE_NORMALIZED_MATCH,
-                       a->a_nvals ? a->a_nvals : a->a_vals,
-                       &ava->aa_value ) == 0 )
-#else
-               if ( value_find( ava->aa_desc, a->a_vals, &ava->aa_value ) == 0 )
-#endif
+                       a->a_nvals, &op->oq_compare.rs_ava->aa_value,
+                       op->o_tmpmemctx ) == 0 )
                {
-                       rc = LDAP_COMPARE_TRUE;
+                       rs->sr_err = LDAP_COMPARE_TRUE;
                        break;
                }
        }
 
-       send_ldap_result( conn, op, rc,
-               NULL, NULL, NULL, NULL );
+       send_ldap_result( op, rs );
 
-       if( rc != LDAP_NO_SUCH_ATTRIBUTE ) {
-               rc = 0;
+       if( rs->sr_err != LDAP_NO_SUCH_ATTRIBUTE ) {
+               rs->sr_err = 0;
        }
 
 
 return_results:;
        cache_return_entry_r( &li->li_cache, e );
        ldap_pvt_thread_rdwr_runlock(&li->li_giant_rwlock);
-       return( rc );
+       return( rs->sr_err );
 }