]> git.sur5r.net Git - openldap/blobdiff - servers/slapd/back-meta/search.c
Improve schema error messages
[openldap] / servers / slapd / back-meta / search.c
index f504745cb44d6642602894763529a1c660781e7d..f1b2f698cb4b7c0c94a653cd7dfe8406f095c99f 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright 1998-2001 The OpenLDAP Foundation, All Rights Reserved.
+ * Copyright 1998-2002 The OpenLDAP Foundation, All Rights Reserved.
  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
  *
  * Copyright 2001, Pierangelo Masarati, All rights reserved. <ando@sys-net.it>
@@ -76,6 +76,9 @@
 #include "../back-ldap/back-ldap.h"
 #include "back-meta.h"
 #include "ldap_pvt.h"
+#undef ldap_debug      /* silence a warning in ldap-int.h */
+#include "ldap_log.h"
+#include "../../../libraries/libldap/ldap-int.h"
 
 static void
 meta_send_entry(
@@ -106,7 +109,7 @@ meta_back_search(
                int             slimit,
                int             tlimit,
                Filter          *filter,
-               const char      *filterstr,
+               struct berval   *filterstr,
                AttributeName   *attrs,
                int             attrsonly
 )
@@ -118,8 +121,8 @@ meta_back_search(
        LDAPMessage     *res, *e;
        int     count, rc = 0, *msgid, sres = LDAP_NO_SUCH_OBJECT;
        char *match = NULL, *err = NULL;
-       char *mbase = NULL, *mfilter = NULL, *mmatch = NULL, 
-               *mapped_filter = NULL, **mapped_attrs = NULL;
+       char *mbase = NULL, *mmatch = NULL;
+       struct berval mfilter;
                
        int i, last = 0, candidates = 0, op_type;
        struct slap_limits_set *limit = NULL;
@@ -157,7 +160,7 @@ meta_back_search(
        /* if requested limit higher than hard limit, abort */
        if ( !isroot && tlimit > limit->lms_t_hard ) {
                /* no hard limit means use soft instead */
-               if ( limit->lms_t_hard == 0 ) {
+               if ( limit->lms_t_hard == 0 && tlimit > limit->lms_t_soft ) {
                        tlimit = limit->lms_t_soft;
                        
                /* positive hard limit means abort */
@@ -175,7 +178,7 @@ meta_back_search(
        /* if requested limit higher than hard limit, abort */
        if ( !isroot && slimit > limit->lms_s_hard ) {
                /* no hard limit means use soft instead */
-               if ( limit->lms_s_hard == 0 ) {
+               if ( limit->lms_s_hard == 0 && slimit > limit->lms_s_soft ) {
                        slimit = limit->lms_s_soft;
                        
                /* positive hard limit means abort */
@@ -193,9 +196,10 @@ meta_back_search(
         * Inits searches
         */
        for ( i = 0, lsc = lc->conns; lsc[ 0 ] != NULL; ++i, ++lsc ) {
-               char *realbase = ( char * )base->bv_val;
-               int realscope = scope;
-               int suffixlen;
+               char    *realbase = ( char * )base->bv_val;
+               int     realscope = scope;
+               ber_len_t suffixlen;
+               char    *mapped_filter, **mapped_attrs;
                
                if ( lsc[ 0 ]->candidate != META_CANDIDATE ) {
                        continue;
@@ -274,9 +278,8 @@ meta_back_search(
                        mbase = realbase;
                }
 #ifdef NEW_LOGGING
-               LDAP_LOG(( "backend", LDAP_LEVEL_DETAIL1,
-                               "[rw] searchBase: \"%s\" -> \"%s\"\n",
-                               base->bv_val, mbase ));
+               LDAP_LOG( BACK_META, DETAIL1,
+                       "[rw] searchBase: \"%s\" -> \"%s\"\n", base->bv_val, mbase, 0 );
 #else /* !NEW_LOGGING */
                Debug( LDAP_DEBUG_ARGS, "rw> searchBase: \"%s\" -> \"%s\"\n%s",
                                base->bv_val, mbase, "" );
@@ -303,22 +306,24 @@ meta_back_search(
                 */
                switch ( rewrite_session( li->targets[ i ]->rwinfo,
                                        "searchFilter",
-                                       filterstr, conn, &mfilter ) ) {
+                                       filterstr->bv_val, conn, &mfilter.bv_val ) ) {
                case REWRITE_REGEXEC_OK:
-                       if ( mfilter == NULL || mfilter[ 0 ] == '\0') {
-                               if ( mfilter != NULL ) {
-                                       free( mfilter );
+                       if ( mfilter.bv_val != NULL && mfilter.bv_val[ 0 ] != '\0') {
+                               mfilter.bv_len = strlen( mfilter.bv_val );
+                       } else {
+                               if ( mfilter.bv_val != NULL ) {
+                                       free( mfilter.bv_val );
                                }
-                               mfilter = ( char * )filterstr;
+                               mfilter = *filterstr;
                        }
 #ifdef NEW_LOGGING
-                       LDAP_LOG(( "backend", LDAP_LEVEL_DETAIL1,
-                                       "[rw] searchFilter: \"%s\" -> \"%s\"\n",
-                                       filterstr, mfilter ));
+                       LDAP_LOG( BACK_META, DETAIL1,
+                               "[rw] searchFilter: \"%s\" -> \"%s\"\n",
+                               filterstr->bv_val, mfilter.bv_val, 0 );
 #else /* !NEW_LOGGING */
                        Debug( LDAP_DEBUG_ARGS,
                                "rw> searchFilter: \"%s\" -> \"%s\"\n%s",
-                               filterstr, mfilter, "" );
+                               filterstr->bv_val, mfilter.bv_val, "" );
 #endif /* !NEW_LOGGING */
                        break;
                
@@ -339,11 +344,16 @@ meta_back_search(
                 * Maps attributes in filter
                 */
                mapped_filter = ldap_back_map_filter( &li->targets[ i ]->at_map,
-                               &li->targets[ i ]->oc_map,
-                               ( char * )mfilter, 0 );
+                               &li->targets[ i ]->oc_map, &mfilter, 0 );
                if ( mapped_filter == NULL ) {
-                       mapped_filter = ( char * )mfilter;
+                       mapped_filter = ( char * )mfilter.bv_val;
+               } else {
+                       if ( mfilter.bv_val != filterstr->bv_val ) {
+                               free( mfilter.bv_val );
+                       }
                }
+               mfilter.bv_val = NULL;
+               mfilter.bv_len = 0;
        
                /*
                 * Maps required attributes
@@ -351,11 +361,10 @@ meta_back_search(
                mapped_attrs = ldap_back_map_attrs( &li->targets[ i ]->at_map,
                                attrs, 0 );
                if ( mapped_attrs == NULL && attrs) {
-                       AttributeName *an;
-                       for ( count=0, an=attrs; an; an=an->an_next, count++ );
+                       for ( count=0; attrs[ count ].an_name.bv_val; count++ );
                        mapped_attrs = ch_malloc( ( count + 1 ) * sizeof(char *));
-                       for ( count=0, an=attrs; an; an=an->an_next, count++ ) {
-                               mapped_attrs[ count ] = an->an_name.bv_val;
+                       for ( count=0; attrs[ count ].an_name.bv_val; count++ ) {
+                               mapped_attrs[ count ] = attrs[ count ].an_name.bv_val;
                        }
                        mapped_attrs[ count ] = NULL;
                }
@@ -364,7 +373,7 @@ meta_back_search(
                 * Starts the search
                 */
                msgid[ i ] = ldap_search( lsc[ 0 ]->ld, mbase, realscope,
-                               mapped_filter, mapped_attrs, attrsonly); 
+                               mapped_filter, mapped_attrs, attrsonly ); 
                if ( msgid[ i ] == -1 ) {
                        lsc[ 0 ]->candidate = META_NOT_CANDIDATE;
                        continue;
@@ -374,14 +383,10 @@ meta_back_search(
                        free( mapped_attrs );
                        mapped_attrs = NULL;
                }
-               if ( mapped_filter != mfilter ) {
+               if ( mapped_filter != filterstr->bv_val ) {
                        free( mapped_filter );
                        mapped_filter = NULL;
                }
-               if ( mfilter != filterstr ) {
-                       free( mfilter );
-                       mfilter = NULL;
-               }
                if ( mbase != realbase ) {
                        free( mbase );
                        mbase = NULL;
@@ -403,9 +408,7 @@ meta_back_search(
                int ab, gotit = 0;
 
                /* check for abandon */
-               ldap_pvt_thread_mutex_lock( &op->o_abandonmutex );
                ab = op->o_abandon;
-               ldap_pvt_thread_mutex_unlock( &op->o_abandonmutex );
 
                for ( i = 0, lsc = lc->conns; lsc[ 0 ] != NULL; lsc++, i++ ) {
                        if ( lsc[ 0 ]->candidate != META_CANDIDATE ) {
@@ -441,7 +444,7 @@ meta_back_search(
                                /* anything else needs be done? */
                                goto finish;
                        } else if ( rc == LDAP_RES_SEARCH_ENTRY ) {
-                               e = ldap_first_entry( lsc[ 0 ]->ld,res );
+                               e = ldap_first_entry( lsc[ 0 ]->ld, res );
                                meta_send_entry(be, op, lc, i, e, attrs,
                                                attrsonly);
                                count++;
@@ -463,10 +466,9 @@ meta_back_search(
                                                LDAP_OPT_MATCHED_DN, &match );
 
 #ifdef NEW_LOGGING
-                               LDAP_LOG(( "backend", LDAP_LEVEL_ERR,
-                                               "meta_back_search [%d]"
-                                               " match=\"%s\" err=\"%s\"\n",
-                                               i, match, err ));
+                               LDAP_LOG( BACK_META, ERR,
+                                       "meta_back_search [%d] match=\"%s\" err=\"%s\"\n",
+                                       i, match, err );
 #else /* !NEW_LOGGING */
                                Debug( LDAP_DEBUG_ANY,
        "=>meta_back_search [%d] match=\"%s\" err=\"%s\"\n",
@@ -520,9 +522,8 @@ meta_back_search(
                                mmatch = ( char * )match;
                        }
 #ifdef NEW_LOGGING
-                       LDAP_LOG(( "backend", LDAP_LEVEL_DETAIL1,
-                                       "[rw] matchedDn: \"%s\" -> \"%s\"\n",
-                                       match, mmatch ));
+                       LDAP_LOG( BACK_META, DETAIL1,
+                               "[rw] matchedDn: \"%s\" -> \"%s\"\n", match, mmatch, 0 );
 #else /* !NEW_LOGGING */
                        Debug( LDAP_DEBUG_ARGS, "rw> matchedDn:"
                                       " \"%s\" -> \"%s\"\n%s",
@@ -578,20 +579,15 @@ meta_send_entry(
 )
 {
        struct metainfo         *li = ( struct metainfo * )be->be_private;
-       char                    *a, *mapped;
+       struct berval           a, mapped;
        Entry                   ent;
-       BerElement              *ber = NULL;
+       BerElement              ber = *e->lm_ber;
        Attribute               *attr, **attrp;
-       struct berval           *dummy = NULL;
-       struct berval           *bv;
+       struct berval           dummy = { 0, NULL };
+       struct berval           *bv, bdn;
        const char              *text;
-       char                    *dn, *edn = NULL;
-       struct berval           tdn;
-
-       struct metasingleconn *lsc = lc->conns[ target ];
 
-       dn = ldap_get_dn( lsc->ld, e );
-       if ( dn == NULL ) {
+       if ( ber_scanf( &ber, "{m{", &bdn ) == LBER_ERROR ) {
                return;
        }
 
@@ -599,43 +595,37 @@ meta_send_entry(
         * Rewrite the dn of the result, if needed
         */
        switch ( rewrite_session( li->targets[ target ]->rwinfo,
-                               "searchResult", dn, lc->conn, &edn ) ) {
+                               "searchResult", bdn.bv_val, lc->conn, &ent.e_name.bv_val ) ) {
        case REWRITE_REGEXEC_OK:
-               if ( edn == NULL ) {
-                       edn = dn;
+               if ( ent.e_name.bv_val == NULL ) {
+                       ent.e_name = bdn;
 
                } else {
 #ifdef NEW_LOGGING
-                       LDAP_LOG(( "backend", LDAP_LEVEL_DETAIL1,
-                                       "[rw] searchResult[%d]:"
-                                       " \"%s\" -> \"%s\"\n",
-                                       target, dn, edn ));
+                       LDAP_LOG( BACK_META, DETAIL1,
+                               "[rw] searchResult[%d]: \"%s\" -> \"%s\"\n",
+                               target, bdn.bv_val, ent.e_name.bv_val );
 #else /* !NEW_LOGGING */
                        Debug( LDAP_DEBUG_ARGS, "rw> searchResult[%d]: \"%s\""
-                                       " -> \"%s\"\n", target, dn, edn );
+                                       " -> \"%s\"\n", target, bdn.bv_val, ent.e_name.bv_val );
 #endif /* !NEW_LOGGING */
-                       free( dn );
-                       dn = NULL;
+                       ent.e_name.bv_len = strlen( ent.e_name.bv_val );
                }
                break;
                
        case REWRITE_REGEXEC_ERR:
        case REWRITE_REGEXEC_UNWILLING:
-               free( dn );
                return;
        }
 
-       tdn.bv_val = edn;
-       tdn.bv_len = strlen( edn );
-
-       dnPrettyNormal( NULL, &tdn, &ent.e_name, &ent.e_nname );
+       dnNormalize2( NULL, &ent.e_name, &ent.e_nname );
 
        /*
         * cache dn
         */
        if ( li->cache.ttl != META_DNCACHE_DISABLED ) {
                ( void )meta_dncache_update_entry( &li->cache,
-                                                  ber_bvdup( &ent.e_nname ),
+                                                  &ent.e_nname,
                                                   target );
        }
 
@@ -644,61 +634,66 @@ meta_send_entry(
        ent.e_private = 0;
        attrp = &ent.e_attrs;
 
-       for ( a = ldap_first_attribute( lsc->ld, e, &ber );
-                       a != NULL;
-                       a = ldap_next_attribute( lsc->ld, e, ber ) )
-       {
-               mapped = ldap_back_map( &li->targets[ target ]->at_map, a, 1 );
-               if ( mapped == NULL ) {
+       while ( ber_scanf( &ber, "{m", &a ) != LBER_ERROR ) {
+               ldap_back_map( &li->targets[ target ]->at_map, 
+                               &a, &mapped, 1 );
+               if ( mapped.bv_val == NULL ) {
                        continue;
                }
                attr = ( Attribute * )ch_malloc( sizeof( Attribute ) );
                if ( attr == NULL ) {
                        continue;
                }
+               attr->a_flags = 0;
                attr->a_next = 0;
                attr->a_desc = NULL;
-               if ( slap_str2ad( mapped, &attr->a_desc, &text )
+               if ( slap_bv2ad( &mapped, &attr->a_desc, &text )
                                != LDAP_SUCCESS) {
-                       if (slap_str2undef_ad(mapped, &attr->a_desc, &text
+                       if ( slap_bv2undef_ad( &mapped, &attr->a_desc, &text 
                                        != LDAP_SUCCESS) {
 #ifdef NEW_LOGGING
-                               LDAP_LOG(( "backend", LDAP_LEVEL_DETAIL1,
-                                               "slap_str2undef_ad(%s): "
-                                               "%s\n", mapped, text ));
+                               LDAP_LOG( BACK_META, DETAIL1,
+                                       "slap_bv2undef_ad(%s): %s\n", mapped.bv_val, text, 0 );
 #else /* !NEW_LOGGING */
                                Debug( LDAP_DEBUG_ANY,
-                                               "slap_str2undef_ad(%s): "
-                                               "%s\n%s", mapped, text, "" );
+                                               "slap_bv2undef_ad(%s): "
+                                               "%s\n%s", mapped.bv_val, text, "" );
 #endif /* !NEW_LOGGING */
-                               ch_free(attr);
+                               ch_free( attr );
                                continue;
                        }
                }
-               attr->a_vals = ldap_get_values_len( lsc->ld, e, a );
-               if ( !attr->a_vals ) {
+
+               /* no subschemaSubentry */
+               if ( attr->a_desc == slap_schema.si_ad_subschemaSubentry ) {
+                       ch_free(attr);
+                       continue;
+               }
+
+               if ( ber_scanf( &ber, "[W]", &attr->a_vals ) == LBER_ERROR 
+                               || attr->a_vals == NULL ) {
                        attr->a_vals = &dummy;
-               } else if ( strcasecmp( mapped, "objectClass" ) == 0 ) {
+
+               } else if ( attr->a_desc == slap_schema.si_ad_objectClass
+                               || attr->a_desc == slap_schema.si_ad_structuralObjectClass ) {
                        int i, last;
-                       for ( last = 0; attr->a_vals[ last ]; ++last ) ;
-                       for ( i = 0; ( bv = attr->a_vals[ i ] ); i++ ) {
-                               mapped = ldap_back_map(
-                                               &li->targets[ target]->oc_map,
-                                               bv->bv_val, 1 );
-                               if ( mapped == NULL ) {
-                                       ber_bvfree( attr->a_vals[ i ] );
-                                       attr->a_vals[ i ] = NULL;
+                       for ( last = 0; attr->a_vals[ last ].bv_val; ++last );
+                       for ( i = 0, bv = attr->a_vals; bv->bv_val; bv++, i++ ) {
+                               ldap_back_map( &li->targets[ target]->oc_map,
+                                               bv, &mapped, 1 );
+                               if ( mapped.bv_val == NULL ) {
+                                       free( bv->bv_val );
+                                       bv->bv_val = NULL;
                                        if ( --last < 0 ) {
                                                break;
                                        }
-                                       attr->a_vals[ i ] = 
-                                               attr->a_vals[ last ];
-                                       attr->a_vals[ last ] = NULL;
-                                       --i;
-                               } else if ( mapped != bv->bv_val ) {
-                                       ch_free( bv->bv_val );
-                                       bv->bv_val = ch_strdup( mapped );
-                                       bv->bv_len = strlen( mapped );
+                                       *bv = attr->a_vals[ last ];
+                                       attr->a_vals[ last ].bv_val = NULL;
+                                       i--;
+
+                               } else if ( mapped.bv_val != bv->bv_val ) {
+                                       free( bv->bv_val );
+                                       ber_dupbv( bv, &mapped );
                                }
                        }
                /*
@@ -715,7 +710,7 @@ meta_send_entry(
                } else if ( strcmp( attr->a_desc->ad_type->sat_syntax->ssyn_oid,
                                        SLAPD_DN_SYNTAX ) == 0 ) {
                        int i;
-                       for ( i = 0; ( bv = attr->a_vals[ i ] ); i++ ) {
+                       for ( i = 0, bv = attr->a_vals; bv->bv_val; bv++, i++ ) {
                                char *newval;
 
                                switch ( rewrite_session( li->targets[ target ]->rwinfo,
@@ -728,13 +723,10 @@ meta_send_entry(
                                                break;
                                        }
 #ifdef NEW_LOGGING
-                                       LDAP_LOG(( "backend",
-                                                       LDAP_LEVEL_DETAIL1,
-                                                       "[rw] searchResult on"
-                                                       " attr=%s:"
-                                                       " \"%s\" -> \"%s\"\n",
-                                       attr->a_desc->ad_type->sat_cname.bv_val,
-                                                       bv->bv_val, newval ));
+                                       LDAP_LOG( BACK_META, DETAIL1,
+                                               "[rw] searchResult on attr=%s: \"%s\" -> \"%s\"\n",
+                                               attr->a_desc->ad_type->sat_cname.bv_val,
+                                               bv->bv_val, newval );
 #else /* !NEW_LOGGING */
                                        Debug( LDAP_DEBUG_ARGS,
                                                "rw> searchResult on attr=%s:"
@@ -742,7 +734,6 @@ meta_send_entry(
                                        attr->a_desc->ad_type->sat_cname.bv_val,
                                                bv->bv_val, newval );
 #endif /* !NEW_LOGGING */
-                                       
                                        free( bv->bv_val );
                                        bv->bv_val = newval;
                                        bv->bv_len = strlen( newval );
@@ -769,15 +760,12 @@ meta_send_entry(
                attr = ent.e_attrs;
                ent.e_attrs = attr->a_next;
                if ( attr->a_vals != &dummy ) {
-                       ber_bvecfree(attr->a_vals);
+                       ber_bvarray_free( attr->a_vals );
                }
                free( attr );
        }
-       if ( ber ) {
-               ber_free( ber, 0 );
-       }
        
-       if ( ent.e_dn ) {
+       if ( ent.e_dn && ent.e_dn != bdn.bv_val ) {
                free( ent.e_dn );
        }
        if ( ent.e_ndn ) {
@@ -792,8 +780,7 @@ is_one_level_rdn(
 )
 {
        for ( ; from--; ) {
-               if ( DN_SEPARATOR( rdn[ from ] ) 
-                               && ! DN_ESCAPE( rdn[ from ] - 1 ) ) {
+               if ( DN_SEPARATOR( rdn[ from ] ) ) {
                        return 0;
                }
        }