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 2c2eb10285367e52157908079fe334a76abc62d3..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,11 +51,6 @@
  * A possible extension will include the handling of multiple suffixes
  */
 
-static int
-meta_back_is_candidate_unique(
-               struct metainfo         *li,
-               struct berval           *ndn
-);
 
 /*
  * returns 1 if suffix is candidate for dn, otherwise 0
@@ -63,13 +59,47 @@ meta_back_is_candidate_unique(
  */
 int 
 meta_back_is_candidate(
-               struct berval   *nsuffix,
-               struct berval   *ndn,
-               int             scope
-)
+       struct berval   *nsuffix,
+       int             suffixscope,
+       struct berval   *ndn,
+       int             scope )
 {
        if ( dnIsSuffix( ndn, nsuffix ) ) {
-               return META_CANDIDATE;
+               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 ) ) {
@@ -82,44 +112,25 @@ meta_back_is_candidate(
        return META_NOT_CANDIDATE;
 }
 
-/*
- * 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
-)
-{
-       switch ( meta_back_select_unique_candidate( li, ndn ) ) {
-       case META_TARGET_MULTIPLE:
-       case META_TARGET_NONE:
-               return 0;
-       }
-
-       return 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, LDAP_SCOPE_BASE ) )
+       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;
@@ -140,16 +151,14 @@ 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;
        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;
                }
@@ -166,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;