use result of validation (ITS#4028)

[openldap] / servers / slapd / back-meta / candidates.c

diff --git a/servers/slapd/back-meta/candidates.c b/servers/slapd/back-meta/candidates.c
index 96f0f2236470bbea9fd2b14c1f5fc3697775e862..aa8c7628df6bdf65931d52121a10919903ff9406 100644 (file)
--- a/servers/slapd/back-meta/candidates.c
+++ b/servers/slapd/back-meta/candidates.c
@@ -23,6 +23,7 @@
 #include "portable.h"
 
 #include <stdio.h>
+#include "ac/string.h"
 
 #include "slap.h"
 #include "../back-ldap/back-ldap.h"
@@ -50,17 +51,6 @@
  * A possible extension will include the handling of multiple suffixes
  */
 
-static int
-meta_back_count_candidates(
-               struct metainfo         *li,
-               struct berval           *ndn
-);
-
-static int
-meta_back_is_candidate_unique(
-               struct metainfo         *li,
-               struct berval           *ndn
-);
 
 /*
  * returns 1 if suffix is candidate for dn, otherwise 0
@@ -69,13 +59,52 @@ meta_back_is_candidate_unique(
  */
 int 
 meta_back_is_candidate(
-               struct berval   *nsuffix,
-               struct berval   *ndn
-)
+       struct berval   *nsuffix,
+       int             suffixscope,
+       struct berval   *ndn,
+       int             scope )
 {
-       if ( dnIsSuffix( nsuffix, ndn ) || dnIsSuffix( ndn, nsuffix ) ) {
+       if ( dnIsSuffix( ndn, nsuffix ) ) {
+               switch ( suffixscope ) {
+               case LDAP_SCOPE_SUBTREE:
+               default:
+                       return META_CANDIDATE;
+
+#ifdef LDAP_SCOPE_SUBORDINATE
+               case LDAP_SCOPE_SUBORDINATE:
+                       if ( ndn->bv_len > nsuffix->bv_len ) {
+                               return META_CANDIDATE;
+                       }
+                       break;
+#endif /* LDAP_SCOPE_SUBORDINATE */
+
+               /* nearly useless; not allowed by config */
+               case LDAP_SCOPE_ONELEVEL:
+                       if ( ndn->bv_len > nsuffix->bv_len ) {
+                               struct berval   rdn = *ndn;
+
+                               rdn.bv_len -= nsuffix->bv_len
+                                       + STRLENOF( "," );
+                               if ( dnIsOneLevelRDN( &rdn ) ) {
+                                       return META_CANDIDATE;
+                               }
+                       }
+                       break;
+
+               /* nearly useless; not allowed by config */
+               case LDAP_SCOPE_BASE:
+                       if ( ndn->bv_len == nsuffix->bv_len ) {
+                               return META_CANDIDATE;
+                       }
+                       break;
+               }
+
+               return META_NOT_CANDIDATE;
+       }
+
+       if ( scope == LDAP_SCOPE_SUBTREE && dnIsSuffix( nsuffix, ndn ) ) {
                /*
-                * suffix longer than dn
+                * suffix longer than dn, but common part matches
                 */
                return META_CANDIDATE;
        }
@@ -83,71 +112,25 @@ meta_back_is_candidate(
        return META_NOT_CANDIDATE;
 }
 
-/*
- * meta_back_count_candidates
- *
- * returns a count of the possible candidate targets
- * Note: dn MUST be normalized
- */
-
-static int
-meta_back_count_candidates(
-               struct metainfo         *li,
-               struct berval           *ndn
-)
-{
-       int i, cnt = 0;
-
-       /*
-        * I know assertions should not check run-time values;
-        * at present I didn't find a place for such checks
-        * after config.c
-        */
-       assert( li->mi_targets != NULL );
-       assert( li->mi_ntargets != 0 );
-
-       for ( i = 0; i < li->mi_ntargets; ++i ) {
-               if ( meta_back_is_candidate( &li->mi_targets[ i ]->mt_nsuffix, ndn ) )
-               {
-                       ++cnt;
-               }
-       }
-
-       return cnt;
-}
-
-/*
- * meta_back_is_candidate_unique
- *
- * checks whether a candidate is unique
- * Note: dn MUST be normalized
- */
-static int
-meta_back_is_candidate_unique(
-               struct metainfo         *li,
-               struct berval           *ndn
-)
-{
-       return ( meta_back_count_candidates( li, ndn ) == 1 );
-}
-
 /*
  * meta_back_select_unique_candidate
  *
- * returns the index of the candidate in case it is unique, otherwise -1
- * Note: dn MUST be normalized.
- * Note: if defined, the default candidate is returned in case of no match.
+ * returns the index of the candidate in case it is unique, otherwise
+ * META_TARGET_NONE if none matches, or
+ * META_TARGET_MULTIPLE if more than one matches
+ * Note: ndn MUST be normalized.
  */
 int
 meta_back_select_unique_candidate(
-               struct metainfo         *li,
-               struct berval           *ndn
-)
+       metainfo_t      *mi,
+       struct berval   *ndn )
 {
        int     i, candidate = META_TARGET_NONE;
 
-       for ( i = 0; i < li->mi_ntargets; ++i ) {
-               if ( meta_back_is_candidate( &li->mi_targets[ i ]->mt_nsuffix, ndn ) )
+       for ( i = 0; i < mi->mi_ntargets; ++i ) {
+               if ( meta_back_is_candidate( &mi->mi_targets[ i ].mt_nsuffix,
+                               mi->mi_targets[ i ].mt_scope,
+                               ndn, LDAP_SCOPE_BASE ) )
                {
                        if ( candidate == META_TARGET_NONE ) {
                                candidate = i;
@@ -168,20 +151,18 @@ meta_back_select_unique_candidate(
  */
 int
 meta_clear_unused_candidates(
-               Operation               *op,
-               struct metaconn         *lc,
-               int                     candidate
-)
+       Operation       *op,
+       int             candidate )
 {
-       struct metainfo *li = ( struct metainfo * )op->o_bd->be_private;
+       metainfo_t      *mi = ( metainfo_t * )op->o_bd->be_private;
        int             i;
-       char            *candidates = meta_back_candidates_get( op );
+       SlapReply       *candidates = meta_back_candidates_get( op );
        
-       for ( i = 0; i < li->mi_ntargets; ++i ) {
+       for ( i = 0; i < mi->mi_ntargets; ++i ) {
                if ( i == candidate ) {
                        continue;
                }
-               candidates[ i ] = META_NOT_CANDIDATE;
+               candidates[ i ].sr_tag = META_NOT_CANDIDATE;
        }
 
        return 0;
@@ -194,22 +175,21 @@ meta_clear_unused_candidates(
  */
 int
 meta_clear_one_candidate(
-               struct metasingleconn   *lsc
-)
+       metasingleconn_t        *msc )
 {
-       if ( lsc->msc_ld ) {
-               ldap_unbind_ext_s( lsc->msc_ld, NULL, NULL );
-               lsc->msc_ld = NULL;
+       if ( msc->msc_ld ) {
+               ldap_unbind_ext_s( msc->msc_ld, NULL, NULL );
+               msc->msc_ld = NULL;
        }
 
-       if ( !BER_BVISNULL( &lsc->msc_bound_ndn ) ) {
-               ber_memfree( lsc->msc_bound_ndn.bv_val );
-               BER_BVZERO( &lsc->msc_bound_ndn );
+       if ( !BER_BVISNULL( &msc->msc_bound_ndn ) ) {
+               ber_memfree( msc->msc_bound_ndn.bv_val );
+               BER_BVZERO( &msc->msc_bound_ndn );
        }
 
-       if ( !BER_BVISNULL( &lsc->msc_cred ) ) {
-               ber_memfree( lsc->msc_cred.bv_val );
-               BER_BVZERO( &lsc->msc_cred );
+       if ( !BER_BVISNULL( &msc->msc_cred ) ) {
+               ber_memfree( msc->msc_cred.bv_val );
+               BER_BVZERO( &msc->msc_cred );
        }
 
        return 0;